예를 들어 vector'vector yielding a vector (# 2472, # 2936), vector 'yielding a matrix, vector' 'yielding matrix (# 2686)는 모두 잘못된 수학입니다.

유한 차원 벡터 공간의 이중 이중은 동일하지 않고 동형입니다. 그래서 나는 이것이 어떻게 나쁜 수학인지 명확하지 않습니다. 인간의 두뇌는 그런 종류의 미끄럽고 모호한 것을 처리하고 올바른 일을하는 데 능숙하기 때문에 수학에서 동형 인 것 사이의 구별에 대해 광택이 나는 경향이 있습니다. 즉, 이것이 개선되어야한다는 데 동의하지만 수학적으로 부정확해서가 아니라 짜증나 기 때문입니다.

v' == v 하지만 v'*v != v*v 어떻게 할 수 있습니까? x' * y 가 자체 연산자라고 생각했던 것보다 더 의미가 있습니까?

유한 차원 벡터 공간의 이중 이중은 동일하지 않고 동형입니다.

(지금 나 자신으로 말하면서) 그것은 단순한 동형이 아니라 자연적으로 동형입니다. 즉 동형은 기본 선택과 무관합니다. 나는 이런 종류의 동형과 정체성을 구별 할 가치가있는 실용적인 응용을 생각할 수 없다. IMO의 성가심 요인은 이런 종류의 구별에서 비롯됩니다.

x' * y 가 자체 연산자라고 생각했던 것보다 더 의미가 있습니까?

그것이 제가 오늘 오후 @alanedelman과의 토론에서 얻은 인상이었습니다.

Jeff가 요구하는 것이 돈에 맞다고 생각합니다.
그 어느 때보 다 감각.

@stefan과 폭력적으로 동의합니다. 나쁜 수학은 의미가 아니라 잘못된 수학이었습니다.
성가신 수학을 의미합니다. 기술적으로 옳지 만 그다지 좋지 않은 것들이 많이 있습니다 ....

이 논리로 가면 다음과 같은 두 가지 선택 사항이 있습니다.

x_x는 오류로 남아 있습니다. ..... 아마도 "점을 사용하고 싶을 수도 있습니다."라는 제안과 함께
또는 x_x는 내적입니다 (저는 그 선택을 좋아하지 않습니다)

x 와 x' 가 동일한 경우 (x')*y 가 dot(x,y) 를 의미하도록하려는 경우 x*y 도 dot(x,y) 임을 의미합니다 x'y 와 x'*y 를 다른 작업으로 만들 수 있지만 그게 좋은 생각인지 모르겠습니다. 사람들은 이것을 명백한 방식으로 괄호로 묶고 여전히 작동하기를 원합니다.

내적을 의미하는 x*x 를 허용하면 기본적으로 되돌아 갈 수 없다는 점을 지적합니다. 그것은 모든 곳에서 사람들의 코드에 들어갈 것이고 그것을 근절하는 것은 악몽이 될 것입니다. 그래서, 자연 동형 이건 아니건, 이것은 순수한 수학이 아닙니다. 그리고 우리는 컴퓨터의 다른 것들이 다르다는 사실을 다루어야합니다.

다음은 내가 좋아하는 "up tuples"와 "down tuples"를 구분하는 실질적인 논의입니다.

http://mitpress.mit.edu/sites/default/files/titles/content/sicm/book-ZH-79.html# % _idx_3310

성가신 사람들을 피하기 위해 "벡터"및 "이중"과 같은 단어는 조심스럽게 피합니다. 편도 함수에 대한 적용이 매력적이라는 것을 알았습니다.

http://mitpress.mit.edu/sites/default/files/titles/content/sicm/book-ZH-79.html# % _sec_Temp_453

M[1,:] 와 M[:,1] 를 구별하는 또 다른 이유는 현재 방송 동작이 매우 편리한 동작을 허용한다는 것입니다. M./sum(M,1) 는 열 확률 적이며 M./sum(M,2) 는 행 확률 적입니다. . norm 함수를 "고정"하여 행과 열에 대한 응용 프로그램을 쉽게 허용하면 정규화에 대해서도 동일하게 수행 할 수 있습니다. 물론, 우리는 여전히 위아래 벡터 대신 sum(M,1) 및 sum(M,2) 반환 행렬을 가질 수 있지만 약간 벗어난 것 같습니다.

나는 위아래 벡터의 아이디어를 좋아합니다. 문제는 완전히 미친 것이 아닌 방식으로 더 높은 차원으로 일반화하는 것입니다. 또는 벡터를 특별한 경우로 만들 수 있습니다. 하지만 그것도 잘못된 것 같습니다.

위 / 아래가 별도의 이론 일 수 있다는 것은 사실입니다. 일반화에 대한 접근 방식은 중첩 구조로 보이며 다른 방향으로 진행됩니다. 그들이 벡터라고 부르지 않는 이유가있을 것입니다.

또한 x*y = dot(x,y) 는 x*(y*z) 대 (x*y)*z 에서와 같이 * 비연 관적으로 만듭니다. 나는 우리가 그것을 피할 수 있기를 정말로 바랍니다.

예. 나에게 그것은 완전히 용납 할 수없는 일입니다. 기술적으로 부동 소수점 * 은 (는) 비연 관적이지만 거의 연관성이있는 반면 이것은 명백하게 비연 관적입니다.

우리 모두는 x*x 이 내적이되어서는 안된다는 데 동의합니다.

v'w 와 v'*w 를 내적이라고 생각할 수 있는지에 대한 질문은 남아 있습니다.
저는이 방식이 정말 마음에 듭니다.

@JeffBezanson 과 나는 채팅을했다

제안은 다음과 같습니다.

v' 는 벡터에 대한 오류입니다 (이것은 mathematica가하는 일입니다).
v'w 및 v'*w 는 내적 (결과 = 스칼라)입니다.
v*w 는 외적 행렬 (결과 = 행렬)입니다.

행 벡터와 열 벡터는 구분되지 않습니다. 나는 어쨌든 이것을 좋아했다
mathematica의 선례를보고 기뻤습니다
Mathematica에서 : http://reference.wolfram.com/mathematica/tutorial/VectorsAndMatrices.html
Mathematica가 목록을 사용하여 벡터와 행렬을 나타내는 방식으로 인해 "행"벡터와 "열"벡터를 구분할 필요가 없습니다.

사용자는 행 벡터가 없다는 것을 알아야합니다. .... 기간.

따라서 M 이 행렬이면

M[1,:]*v 는 오류입니다. ..... ( M[1,:] 한다고 가정하면 스칼라
경고는 dot 또는 '* 또는 M[i:i,:] 시도를 제안 할 수 있습니다.

M[[1],:]*v 또는 M[1:1,:]*v 는 길이가 1 인 벡터입니다 (어쨌든 julia의 현재 동작입니다).

https://groups.google.com/forum/#!topic/julia -users / L3vPeZ7kews의 밀접한 관련 문제에 대해

Mathematica는 스칼라와 유사한 배열 섹션을 압축합니다.

m = Array[a, {2, 2, 2}] 


Out[49]= {{{a[1, 1, 1], a[1, 1, 2]}, {a[1, 2, 1], 
   a[1, 2, 2]}}, {{a[2, 1, 1], a[2, 1, 2]}, {a[2, 2, 1], a[2, 2, 2]}}}

In[123]:= Dimensions[m]
Dimensions[m[[All, 1, All]]]
Dimensions[m[[2, 1, All]]]
Dimensions[m[[2, 1 ;; 1, All]]]

Out[123]= {2, 2, 2}

Out[124]= {2, 2}

Out[125]= {2}

Out[126]= {1, 2}

[편집 : 코드 서식 – @StefanKarpinski]

안녕하세요.

M [1 ,:]이 스칼라라고 가정하면

M [1 ,:]이 단지 벡터라는 뜻인가요?

네 죄송합니다. 내 마음은 M [1 ,:]이 스칼라 1을 처리하고 있음을 의미했습니다. :-)

Mathematica는 별표 * 대신 마침표 . 사용합니다.
그런 다음 전체 9 야드를 이동하여 (vector. vector)를 스칼라로 만듭니다.
별표와 함께.

의심 할 여지없이이 기간에는 많은 문제가 있습니다. 그 중 하나는
내적의 "점"처럼 보이며 다른 하나는
점의 "점 단위 연산"판독,

유니 코드는 "점 연산자"라는 이름의 문자를 매우 멋지게 제공합니다.
⋅ (char(8901)) 우리가 상상할 수있는 제안

그래서 우리는 (v ⋅ w) 가 (v'*w) 와 동의어가 될 수 있습니다.

요약하자면 현재 토론 주제는

1. 스칼라 인덱싱은 차원을 죽입니다.
   A[i,:] 는 A[:,i,j] 그대로 벡터입니다.
2. 벡터 인덱싱이 두껍습니다.
   A[ i:i , : ] 또는 A[ [i], : ] 는 행이 하나 인 행렬을 반환합니다.
3. v'w 또는 v'*w 는 벡터의 내적 (외적의 경우 v*w' 과 유사 함)입니다.
4. v' 는 벡터에 대해 정의되지 않았습니다 (사용자를 permutedims(v,1) ????로 가리킴).
5. v*A 는 A가 행렬이면 벡터를 반환합니다.
6. v⋅w 도 내적을 반환합니다 (그러나 행렬 작업을 통해 mathematica의 . 만큼 멀리 가지 않습니다.
7. v*w 는 벡터에 대해 정의되어 있지 않지만 다음과 같은 좋은 제안으로 사용자에게 경고가 표시 될 수 있습니다.
   ⋅

결과는

ㅏ. 모든 벡터를 열 벡터로 고수하면 모든 것이 작동합니다.
비. 모든 것을 행렬로 만들면 모든 것이 확실히 작동하며 모든 것을 행렬로 만드는 것은 쉽습니다.
씨. 당신의 마음이 행 벡터와 1 행 행렬을 구별 할 수 없다면, 당신은 교육을받을 가능성이 있습니다.
정중하고 우아하게
디. 이 점 표기법 ⋅ 은 눈에 쾌적합니다

제안 5) 나에게 매우 이상하게 보입니다. 저는 v'*A 선호하므로 이중 벡터를 사용하고 있음을 분명히 알 수 있습니다. 이것은 이중이 단순한 "모양"변환이 아닌 복잡한 벡터 공간에서 특히 중요합니다.

나는이 모든 것에서 우리의 간결한 방송 행동을 잃는 것이 오히려 불행 할 것이라고 v 를 취하고 행렬 A 의 열을 해당 값으로 정규화하는 간결한 구문은 무엇입니까? 현재 A ./ v' 사용할 수 있습니다. 이것은 데이터 조작에 매우 좋습니다.

좋은 질문

내 계획은 v의 복잡한 켤레를 취하고 A로 다중화하는 것을 v'*A 배제하지 않습니다.
그리고 제가 아직 명시 적으로 언급하지 않았지만 쉽게

우리는 5를 제거 할 수 있습니다
아마도 그것은 바람직하다
내 열 벡터 규칙을 준수하지 않습니다.

방송에 대한 이런 접근 방식은 귀엽고 어설픈
이제 하나의 솔루션은 A ./ v[:,[1]]

어느 차원에서 방송되고 있는지 문서화하는 이점이 있습니다.
더 높은 차원의 배열로 일반화합니다.

아 그리고 v[:,[1]] 솔루션은 복잡한 켤레를 취하지 않는 미덕이 있습니다.
아마도 사용자가 의도 한 것입니다 .....

첫 번째는 LINEAR ALGEBRA 예제이기 때문에이 두 예제를 좋아합니다.
복잡한 켤레가 매우 자주 필요하지만 두 번째 예는
모든 차원에서 작동하기를 원하는 다차원 데이터 예제
행렬뿐만 아니라 복잡한 켤레를 원하지 않을 가능성이 큽니다.

⋅ 에는 # 552가 필요합니다. 지난 2 주 동안 세 번째로 나타났습니다.

M [1 ,:]과 M [:, 1]을 구별하는 또 다른 이유는 현재 우리의 방송 동작이 매우 편리한 동작을 허용한다는 것입니다. M./sum(M,1)은 열 확률 적이며 M./sum(M, 2) 행 확률 적입니다. 행과 열을 쉽게 적용 할 수 있도록 norm 함수를 "고정"하면 정규화에 대해서도 동일하게 수행 할 수 있습니다. 물론 우리는 여전히 sum (M, 1) 및 sum (M, 2)이 위아래 벡터 대신 행렬을 반환 할 수 있지만 약간 벗어난 것 같습니다.

방송 동작이 좋은 편이긴하지만, 그 여분의 유닛을 자주 짜 내야하는 것 같습니다. 따라서 시스템의 나머지 부분이 더 좋으면 어느 정도 반대의 작업을 수행하는 것이 좋습니다 (그리고 스칼라 차원이 떨어지면 시스템이 더 좋아질 것이라고 생각합니다). 따라서 다음과 같은 기능이 필요합니다.

julia> widen(A::AbstractArray,dim::Int) = reshape(A,insert!([size(A)...],dim,1)...)
# methods for generic function widen
widen(A::AbstractArray{T,N},dim::Int64) at none:1

M ./ widen(sum(M,2),2) 또는 A ./ widen(v,1) 와 같은 코드를 허용합니다 (위의 @blakejohnson 예제 참조).

M [:, 0 ,:] 및 v [:, 0] ?????

나는 감소 문제에 대해 @blakejohnson 과 더 많이 있습니다. 나는 개인적으로가 명확하다고 생각 squeeze 보다는 치수 widen 그들. 나는 widen 가 표시된 인덱스 또는 그 뒤에 차원을 삽입하는지 여부를 파악하기 위해 문서를 계속 살펴보고있을 것이며, 한 번에 여러 차원을 넓히려면 번호 매기기가 조금 더 복잡해집니다. (벡터 v widen(v, (1, 2)) 대한 squeeze 대한 문제는 없습니다.

우리가 기본적으로 확대하든 축소하든 관계없이 Julia는 확장에 관해서는 numpy의 선두를 따라야하고 v[:, newaxis] 와 같은 것을 허용해야한다고 생각합니다. 그러나 나는 치수를 버리는 대신 유지하는 것을 선호한다고 생각하며, 잘못된 방법을 눌렀을 때 (일반적으로 오류가 발생 함)보다 실수로 잘못된 방법을 확장 한 버그를 잡는 것이 더 어렵습니다.

@alanedelman 목록에서
나는 그것을 느낀다

v * A는 A가 행렬이면 벡터를 반환합니다.

좋지 않다.

A가 1x1 (인덱스 범위 불일치)이 아니면 v_A는 오류 여야합니다.
v'_A는 적절한 방법이어야합니다.

이 문제를 처리하는 한 가지 방법은 벡터 v를 nx1 행렬로 자동 변환하는 것입니다 (필요한 경우).
v '를 항상 1xn 행렬로 취급합니다 (벡터 또는 nx1 행렬로 변환하지 마십시오)
또한 1x1 행렬을 스케일러 번호로 자동 변환 할 수 있습니다 (필요한 경우).

나는 이것이 선형 대수에 대해 생각하는 일관되고 균일 한 방식을 나타낸다고 생각합니다. (좋은 수학)

이러한 모든 문제를 처리하는 일관된 방법은 자동 (유형?) 변환 (필요한 경우)을 허용하는 것입니다.
크기 (n), (n, 1), (n, 1,1), (n, 1,1,1) 등의 배열 사이 (크기가 (n, 1) 및 (1, n) 인 배열 사이는 아님) )
(필요할 때 실수를 복소수로 자동 변환하는 것과 같습니다.)

이 경우 크기 (1,1)의 배열을 숫자로 변환 할 수 있습니다 (필요한 경우) (# 4797 참조).

Xiao-Gang (물리학 자)

이것은 v'_A를 남겨 두지 만 .... 나는 v'_A * w가 작동하기를 정말로 원합니다

줄리아의 선형 대수에 대한 내 인상은 스칼라와 실제 벡터가 존재하지만 (좋은 것 같습니다!) 행렬 대수처럼 매우 조직화되어 있다는 것입니다.

x*y*z*w 와 같은 제품을 처리하는 방법을 고려해 보겠습니다. 여기서 각 요소는 스칼라, 벡터 또는 행렬 일 수 있으며 전치가있을 수 있습니다. 행렬 대수는 행렬의 크기가 n x m 인 행렬의 곱을 정의합니다. 한 가지 접근 방식은이 정의를 확장하여 n 또는 m 을 absent 로 대체하여 제품을 계산하는 한 1의 값처럼 작동하도록하는 것입니다. , 그러나 행렬과 스칼라 및 벡터를 구별하는 데 사용됩니다.

• 스칼라는 absent x absent
• (열) 벡터는 n x absent
• 행 벡터는 absent x n

이상적으로는 행 벡터를 표현할 필요가 없도록 배열하고 싶지만 x'*y 및 x*y' 같은 연산을 구현하는 것으로 충분합니다. 나는 이것이 우리 중 많은 사람들이 찾고있는 계획의 맛이라는 느낌을 받는다.

그러나 나는 이런 종류의 계획에서 행 벡터를 금지하는 것이 높은 비용을 초래할 것이라고 의심하기 시작했습니다. 예 : 중간 단계에서 행 벡터가 형성되지 않도록 제품을 괄호로 묶는 방법을 고려하십시오. ( a 는 스칼라, u 및 v 는 벡터입니다)

a*u'*v = a*(u'*v) // a*u' is forbidden
v*u'*a = (v*u')*a // u'*a is forbidden

행 벡터 생성을 피하면서 제품 x*y'*z 을 평가하려면 곱셈 순서를 선택하기 전에 요인 유형을 알아야합니다! 사용자가 직접해야한다면 일반 프로그래밍에 장애가되는 것처럼 보입니다. 그리고 Julia가 어떻게 자동으로 정상적인 방식으로 할 수 있는지 잘 모르겠습니다.

곱셈 순서를 미리 수정하지 않는 또 다른 이유 : 필요한 연산 수를 최소화하기 위해 *(x,y,z,w) 의 최적 평가 순서를 선택하기 위해 동적 프로그래밍을 사용하는 아이디어가 있다는 것을 기억하는 것 같습니다. 행 벡터 형성을 방지하기 위해 수행하는 모든 작업이이를 방해 할 수 있습니다.

그래서 지금 당장 전치 벡터 유형을 도입하는 것은 나에게 가장 건전한 대안처럼 보입니다. 또는 지금 모든 것을 수행하지만 유지하는 경우 후행 단일 치수를 삭제하면 오류가 발생합니다.

조옮김은 모드를 변경하는 특별한 방법입니다. v 가 벡터 인 v.' 를 허용하면 permutedims(v,[2 1]) 는 똑같은 것을 반환해야합니다. 둘 다 특수 행 벡터 유형을 반환하거나 새 차원을 도입합니다.

다른 유형의 모드 -n 벡터 (예 : permutedims([1:4],[3 2 1]) 무엇을 하시겠습니까? 결정을 내리기 전에 다 선형 대수도 고려해 보시기 바랍니다.

@toivoh가 언급했습니다.

"한 가지 접근 방식은 n 또는 m이 부재로 대체 될 수 있도록이 정의를 확장하는 것입니다. 이는 제품을 계산하는 한 1의 값처럼 작동하지만 스칼라와 벡터를 행렬과 구별하는 데 사용됩니다.

1. 스칼라는 부재 x 부재
2. (열) 벡터는 nx가 없을 것입니다.
3. 행 벡터는 xn "이 없을 것입니다.

다중 선형 대수 (또는 높은 랜드 텐서의 경우)에서 위의 제안은
범위 1의 많은 인덱스, 즉 크기 (m, n, absent)는 (m, n), (m, n, 1), (m, n, 1,1) 등에 해당 할 수 있습니다.

absent에 대한이 해석을 사용하면 1.과 2.는 괜찮고 가지고 있으면 좋지만 3.은 괜찮지 않을 수 있습니다.
크기가 (1, n)과 (1,1, n) 인 배열을 혼합하고 싶지 않습니다.

나는 텐서 이론의 전문가는 아니지만 선형 대수를 포함하는 실질적인 프로젝트를 위해 위에서 언급 한 모든 시스템 (애드온 패키지없이)을 사용했습니다.

[TL; DR : 요약으로 건너 뛰기]

다음은 일반적인 행렬-벡터 연산보다 배열 처리에서 더 큰 일반성이 필요하다는 것을 발견 한 가장 일반적인 시나리오입니다.

(1) 함수 분석 : 예를 들어 벡터 값 함수의 헤세 행렬을 사용하는 즉시 작동하려면 고차 텐서가 필요합니다. 수학을 많이 작성하는 경우 이러한 경우에 특수 구문을 사용해야하는 것은 큰 고통입니다.

(2) 평가 제어 : 예를 들어 계산할 수있는 제품이 주어지면 해당 제품의 하위 항목을 개별적으로 계산할 수 있어야합니다. 왜냐하면 여러 다른 하위 항목과 결합하여 서로 다른 제품을 형성 할 수 있기 때문입니다. 따라서 예를 들어 a*u' 금지에 대한 Toivo의 우려는 컴파일 문제가 아니라 프로그래밍 문제입니다. 훨씬 더 일반적인 변형은 x'Q 를 사전 계산하여 2 차 형식 x'Q*y1 , x'Q*y2 , ... (여기서는 순차적으로 수행해야 함)을 계산하는 것입니다.

(3) 코드 단순화 : 다차원 데이터 세트에 매핑 된 산술 연산을 다룰 때 여러 번, 시스템에서 6-7 줄의 알 수없는 루핑 또는 함수 매핑 코드를 하나 또는 두 개의 간단한 배열 연산으로 대체 할 수 있음을 발견했습니다. 적절한 보편성을 제공합니다. 훨씬 더 읽기 쉽고 훨씬 빠릅니다.

위 시스템에 대한 일반적인 경험은 다음과 같습니다.

MATLAB : 핵심 언어는 일반적인 행렬-벡터 연산 이상으로 제한되므로 일반적으로 인덱싱으로 루프를 작성합니다.

NumPy : MATLAB보다 더 일반적인 기능이지만 지저분하고 복잡합니다. 거의 모든 사소하지 않은 문제 인스턴스에 대해 문서를 참조해야했고, 그 후에도 가끔은 직관적으로 정의해야한다고 생각하는 배열 작업을 직접 구현해야한다는 사실을 발견했습니다. 시스템에 너무 많은 개별 아이디어가있어 특정 사용자와 개발자는 상대방이 어떤 것에 대해 어떻게 생각할지 자동으로 추측하는 데 어려움을 겪을 것 같습니다. 일반적으로 짧고 효율적인 방법을 찾는 것이 가능하지만 그 방법이 작가 나 독자에게 항상 분명하지는 않습니다. 특히, 확장 및 단일 차원의 필요성은 연산자 적용 구현의 일반성이 부족하다는 것을 반영한다고 생각합니다 (일부는 더 직관적이라고 생각할 수도 있습니다).

Mathematica : 깨끗하고 매우 일반적입니다. 특히 모든 관련 연산자는 고차 텐서 동작을 염두에두고 설계되었습니다. Dot 외에도 Transpose, Flatten / Partition 및 Inner / Outer에 대한 문서를 참조하십시오. 이러한 연산 만 결합하면 이미 대부분의 배열 저글링 사용 사례를 다룰 수 있으며 버전 9에서는 핵심 언어에 추가 텐서 대수 연산이 추가되었습니다. 단점은 Mathematica가 무언가를하는 방식이 깨끗하고 말이되지만 (언어를 알고 있다면), 그것을 수행하는 일반적인 수학적 표기법과 분명히 일치하지 않을 수 있다는 것입니다. 물론 일반성으로 인해 코드가 어떻게 수행되는지 알기가 어렵습니다.

scmutils : 기능 분석의 경우 깔끔하고 일반적이며 위의 작업 중 가장 수학적으로 직관적 인 작업 (쓰기 및 읽기 모두)을 제공합니다. up / down 튜플 아이디어는 사람들이 전치 기호, 미분 관례 및 기타 준 표준화 개념을 사용하는 서면 수학에서 종종하는 일을 더 일관되고 더 일반적으로 확장 한 것입니다. 그러나 모든 것이 작동합니다. (박사 학위 논문을 작성하기 위해 전통적인 수학 표기법과 유사하지만 Sussman & Wisdom의 SICM 구문과 동형 인 일관되고 모호하지 않은 표기법을 개발했습니다.) 그들은 또한 미분 기하학 구현 [1]을 위해 그것을 사용했습니다. SymPy [2] 로의 이식에 영감을주었습니다. 데이터 분석에 사용하지는 않았지만 한 종류의 튜플 (예 : Mathematica의 목록) 만 원하는 일반 배열 컨텍스트에서는 관례에 따라 하나 ( "up") 만 선택할 수 있습니다. 다시 말하지만, 일반성은 프로그래머에게 성능 고려 사항을 모호하게하지만 이것이 Julia가 뛰어난 분야가되기를 바랍니다.

요약

제안 된 전치 벡터 유형은 scmutils에서보다 일반적인 "다운"튜플로 특성화되어야하며 일반 벡터는 "업"튜플이 될 것입니다. "벡터"및 "전치 벡터"와 같은 것으로 호출하는 것은 "위로"및 "아래로"(간결성을 희생하여)라고 부르는 것보다 사람들에게 더 합리적 일 것입니다. 이것은 세 가지 사용 범주를 지원합니다.

(1) 데이터 분석을 위해 사람들이 중첩 배열을 원하면 "벡터"만 필요합니다.
(2) 기본적인 행렬-벡터 선형 대수를 위해, 사람들은 수학적 관례에 직접적으로 대응하여 "벡터"와 "전치 벡터"를 사용할 수 있습니다 ( "행렬"은 "벡터"의 "전치 벡터"와 동일 함).
(3) 고차 텐서 연산의 경우 (표준화가 적고 사람들이 일반적으로 어쨌든 생각해야하는 경우) 구현은 2 종류 튜플 산술 시스템의 완전한 일반성을 지원해야합니다.

이 접근 방식은 이전 게시물에서 오류를 고려한 사례 ( v' 및 v*A )가 실제로 의미 있고 유용한 정보를 제공한다는 점을 제외하고는 다양한 작업 결과에 대한 위의 새로운 합의를 반영한다고 생각합니다. ) 결과.

[1] http://dspace.mit.edu/handle/1721.1/30520
[2] http://krastanov.wordpress.com/diff-geometry-in-python/

@thomasmcoffee는 공변량 벡터와 반

나는 그것을 일반적인 응용 프로그램이라고 생각하지만 내가 옹호하는 것에 대해 지나치게 구체적입니다. 저에게 그것은 (좌표 표현을 위해) 숫자의 직사각형 텐서에 대한 제한을 암시하는 기하학적 의미를 가지고 있습니다. 이 분야에 대한 전문 지식 없이는 표준 배열이있는 텐서 대수 함수의 적절한 라이브러리가 일반적으로이 목적에 충분할 것이라고 상상하기 때문에, 이것만으로는 두 종류의 시스템을 핵심 언어.

저는 주로 더 일반적인 중첩 구조에 의존하는 다른 응용 프로그램을 생각하고 있습니다. 예를 들어 혼합 차원의 여러 인수 함수에 대한 미적분은 핵심 언어가 지원하지 않으면 나중에 "추가 기능"으로 개발하기가 더 어려울 것입니다. 이 구별. 아마도 우리는 같은 것을 의미 할 것입니다.

상향 및 하향 벡터의 문제점은 아이디어를 일반 배열로 확장해야한다는 것입니다. 그렇지 않으면 벡터는 배열의 1 차원 케이스 대신에 특별한 무언가가되고 배열과 분리되어 끔찍한 문제로 이어질 것입니다. 그 방법에 대해 많은 생각을했지만 받아 들일만한 방법을 찾지 못했습니다. 위아래 벡터를 배열로 올바르게 일반화하는 방법에 대한 좋은 아이디어가 있다면 듣고 싶습니다.

이 아이디어를 외삽하려고합니다. 내가 이해했듯이 배열을 사용하여 위아래 벡터로 계산하려면 각 차원에 대해 위아래인지 여부를 표시해야합니다. 일반적으로 이것은 배열을 다음과 같이 감싸서 얻을 수 있습니다.

immutable UpDownTensor{T, N, UPMASK} <: AbstractArray{T, N}
    A::AbstractArray{T, N}
end

여기서 UPMASK 는 어떤 차원이 올라 갔는지 나타내는 비트 마스크입니다. 그리고 비 감싸 배열에 대한 작업이 기본을 제공함으로써 구현 될 수 UPMASK 의 함수로 N : 벡터는 하나의 최대 기본 것, 첫 번째 위 두 번째 아래에 매트릭스; 그러면 어떻게 합리적으로 계속 될지 모르겠습니다.

임의의 생각 :

• 2 차 / 쌍 선형이 2 차원으로 더 잘 표현 될까요?
• 트랜스 포즈가 각 차원의 위 / 아래를 뒤집는 것에 해당한다면, 우리는 또한 첫 번째 차원이 아래로, 두 번째가 위로있는 전치 행렬 유형을 얻을 것이라고 생각합니다.
• 기본값에 해당하는 업 패턴은 래핑하는 대신 기본 배열로 직접 표현할 수 있습니다.

음, 이것은 확실히 Transposed 유형의 일반화이며 확실히 장점이 있습니다. 실행 가능한지 확실하지 않습니다.

나는 Toivo의 제안이 내가 위에서 옹호했던 것에 대한 합리적인 실현이라고 생각합니다. 나에게 가장 현명한 기본값은 더 높은 순서로 방향을 계속 바꾸는 것입니다. 예를 들어 누군가가 멱급수의 구성 요소를 래핑되지 않은 배열로 제공했다면 이것은 올바른 일을 할 것입니다.

그러나 더 깊이 생각해 보면 두 가지 아이디어를 결합하는 것이 매우 강력 할 수 있다고 생각합니다. (1) 위아래 벡터 간의 구별과 (2) 배열과 벡터 간의 구별입니다. 그런 다음 일부 차원은 위로, 일부는 아래로, 일부는 "중립"인 객체를 가질 수 있습니다. 배열과 벡터를 구별하는 이유는 의미 상 배열은 구성 (동일한 종류의 여러 항목 수집)을위한 반면 벡터는 조정 (다차원 공간을 나타냄)을위한 것입니다. 하나의 객체에서 두 가지 구별을 결합하는 힘은 두 가지 목적을 동시에 제공 할 수 있다는 것입니다. 중립 차원은 방송 규칙에 따라 처리되고 위 / 아래 차원은 텐서 산술 규칙에 따라 처리됩니다.

이전 예제로 돌아가서 다른 벡터 y1, y2, ... 대해 여러 2 차 형식 x'Q*y1, x'Q*y2, ... 을 계산한다고 가정합니다. SICM 이어 의해 튜플 (열 벡터)를 나타낸다 (...) 의해 튜플 (행 벡터) 아래 [...] . 이 모든 작업을 한 번에 수행하고 싶고 위 / 아래로만 고착 된 경우 일반적인 방법은 yi 를 아래로 튜플을 사용하여 Y = [y1, y2, ...] 행렬로 결합하는 것입니다. up tuples), 그리고 r = x'Q*Y 계산하면 결과는 down tuple r 입니다. 하지만 이러한 각 결과에 (열) 벡터 v 를 곱하려면 어떻게해야합니까? r*v 를 할 수는 없습니다. 수축 (내적)이 생기기 때문입니다. r 를 업 튜플으로 변환 한 다음 곱하면 업 튜플 (업 튜플)의 결과를 얻을 수 있습니다. 그러나 다음 단계를 위해 다운 튜플이 필요하다고 가정합니까? 의미 론적으로, 당신은 항상 방송되기를 원하는 것들의 모음을 나타내는 계산을 거치는 차원을 가지고 있습니다. 그러나 엄격하게 업 / 다운 세계에서이를 달성하려면 올바른 동작을 이끌어 내기 위해 임의의 컨텍스트 종속 변환을 계속 수행해야합니다.

반대로 {...} 로 표시된 중립 튜플 (배열)도 있다고 가정합니다. 그런 다음 자연스럽게 ys = {y1, y2, ...} 를 배열 (업 튜플)로 작성하여 r = x'Q*ys 가 배열이고 r*v 도 배열 (업 튜플)이되도록합니다. 모든 것이 합리적이며 임의의 변환이 필요하지 않습니다.

Stefan은 1-D 배열과 up / down 벡터를 구별하는 것은 비참한 일이라고 제안하지만 대부분의 함수가 배열의 벡터 _or_에서 작동하지만 _ 둘 다 _가 아니라 작동한다는 사실에 의해이 문제가 해결된다고 생각합니다. (또는 벡터 배열의 행렬 _or_ 배열 벡터의 배열 _or_ 배열 배열의 _or_ 그러나 _ either_ 아님. 등등.) 따라서 적절한 변환 규칙을 사용하면 수행하지 않을 일반적인 경우를 생각하지 않았습니다. 자동으로 옳은 일. 누군가가 할 수 있습니까?

자세히 살펴보면 [1] scmutils가 실제로 "벡터"라고 부르는 것과 후드 아래의 위아래 튜플을 구별한다는 사실을 발견했습니다. 그러나 현재 변환 규칙은 이러한 "벡터"가 업 / 다운 세계에 들어갈 때마다 업 튜플에 매핑되도록 설정되어 있습니다 (앞서 제안했듯이). "우리는이 구현을 구별하기 위해 변경할 권리가 있습니다. 업 튜플의 스키마 벡터. " (아마도 캠퍼스에있는 누군가가 GJS에게 구체적인 아이디어가 있는지 물어볼 수 있습니다.) Sage 시스템 [2]은 배열 처리를 벡터 및 행렬 (현재 텐서에 대한 핵심 지원이 없음)과 크게 분리하며 제가 경험 한 유일한 문제입니다. 이것은 분명히 의미가있는 경우에 그들 사이에 내장 된 변환의 부족과 관련이 있습니다.

[1] http://groups.csail.mit.edu/mac/users/gjs/6946/refman.txt --- "구조화 된 객체"에서 시작
[2] http://www.sagemath.org/

나는 점심 테이블에서 @jiahao 와 이야기하고

잠시 동안 두 어레이 간의 곱만 고려해 보겠습니다. 다른 작업은 유사한 일반화를 갖습니다. 배열을 다룰 때 가장 일반적인 세 ​​가지 유형의 제품은 외부 제품, 내부 제품 및 요소 별 제품입니다. 일반적으로 inner(A,B) 또는 A*B 와 같은 두 개체간에 이와 같은 작업을 수행하는 것을 생각합니다. 그러나 고차원 배열에서 이러한 작업을 수행 할 때는 배열 전체가 아니라 배열의 특정 차원간에 수행됩니다. 여러 외부 / 내부 / 요소 별 하위 작업은 두 배열 사이의 단일 작업에서 발생하며 각 배열의 각 차원은 정확히 하나의 하위 작업 (명시 적으로 또는 기본값)에 할당되어야합니다. 내부 및 요소 별 제품의 경우 왼쪽에있는 하나의 차원은 오른쪽에있는 동일한 크기의 차원과 쌍을 이루어야합니다. 외부 제품 치수는 쌍을 이룰 필요가 없습니다. 대부분의 경우 사용자는 한 쌍의 차원과 다른 모든 제품에 대한 외부 제품 사이에서 내부 제품 또는 요소 별 제품을 수행합니다. 외부 제품은 가장 일반적이고 쌍을 이룰 필요가 없기 때문에 좋은 기본값이됩니다.

나는 보통 플롯의 x, y, z 축과 같이 순서가 지정되지 않고 이름이 지정되는 것으로 치수를 생각합니다. 당신이 원한다면 사용자가 실제로 주문 인덱싱하여 배열에 액세스 할 수 있도록 (같은 A[1,2,5] 보다는 A[a1=1, a3=5, a2=2] ) 당신은 작업의 결과를 정렬 할 수있는 일관된 방법을 가지고 있습니다. 첫 번째 배열의 모든 차원을 나열한 다음 두 번째 배열의 모든 차원을 나열하여 결과를 정렬 할 것을 제안합니다. 내부 곱에 참여한 모든 차원이 압착되고 요소 별 곱에 참여한 차원의 경우 두 번째 배열의 차원 만 압착됩니다.

나는 이것에 대한 몇 가지 표기법을 만들 것입니다. 그것을 Juliafy 자유롭게 느끼십시오. A a1 x a2 x a3 인 배열로, B 를 b1 배열로 지정 b2 . array_product(A, B, inner=[2, 1], elementwise=[3, 2]) 이 차원 a2 및 b1 사이의 내부 곱, a3 및 b2 사이의 요소 별 곱을 취한다고 가정 해 보겠습니다. a1 의 외부 제품. 결과는 a1 x a3 배열이됩니다.

이항 또는 단항 연산자는 고차원 배열의 맥락에서 많은 의미를 갖지 않을 것임이 분명합니다. 각 차원으로 수행 할 작업을 지정하려면 두 개 이상의 인수가 필요합니다. 그러나 Matlab 연산자를 처음 두 차원에 대한 배열 연산의 약자로 만들어 선형 대수의 용이성을 다시 캡처 할 수 있습니다.

Matlab의 A*B 은 array_product(A, B, inner=[2,1]) 입니다.

Matlab의 A.' 는 permute(A, B, [2,1]) 이며, 여기서 permute는 세 번째 인수의 개수보다 높은 모든 차원을 변경하지 않고 유지합니다.

Mathematica가 벡터 전치와 같이 배열의 차원이 2보다 크거나 2와 같지 않을 때 오류를 발생 시킬지 여부를 선택할 수 있습니다. 일반적인 배열 계산 만 사용하는 경우 모든 (n, m) 배열을 (n, m, 1) 및 (n, m, 1)로 해석하기 위해 @wenxgwen 의 제안을 받아 @wenxgwen 의 제안을 좋아합니다.

배열 미적분에 대한 체인 규칙 및 곱 규칙과 함께 더하기, 지수화 및 미분을 포함하는 시스템에 대한 자세한 설명을 작성했습니다.

관점에 감사드립니다! 나는 이것이 일반적인 배열 * 배열 제품이 실제로 어떤 종류의 짐승인지 이해하는 데 상당히 계몽 적이라는 것을 알았습니다.

PEP 0465 에서 행렬 곱셈 연산자에 대해 제안 된 의미론과 다차원 배열 곱셈에 대한 제안을 상호 참조하는 것이 흥미로울 수 있습니다. 특히:

1d 벡터 입력은 모양 앞에 '1'을 추가하거나 추가하여 2d로 승격되고 작업이 수행 된 다음 추가 된 차원이 출력에서 ​​제거됩니다. 1은 항상 모양의 "외부"에 추가됩니다. 왼쪽 인수에는 앞에 추가되고 오른쪽 인수에는 추가됩니다. 결과적으로 행렬 @ 벡터와 벡터 @ 행렬은 모두 합법적이며 (호환 가능한 모양을 가정) 둘 다 1d 벡터를 반환합니다. 벡터 @ 벡터는 스칼라를 반환합니다 ... 1d 벡터에 대한이 정의의 잘못된 점은 경우에 따라 @가 비연 관적이라는 것입니다 ((Mat1 @ vec) @ Mat2! = Mat1 @ (vec @ Mat2)). 그러나 이것은 실용성이 순수성을 능가하는 경우 인 것 같습니다

파이썬에서 더킹 타이핑은 특별한 문제를 일으 킵니다. 당연히 배열과 행렬은 상호 교환 가능해야합니다 (동일한 기본 데이터). 그러나 파이썬은 유형 검사를 권장하지 않기 때문에 배열을 예상하는 함수의 시작 부분에서 행렬이 올바른 인터페이스로 캐스팅되지 않으며 그 반대의 경우도 마찬가지입니다. 이것이 다른 연산자 문자를 가져야하는 이유입니다. 런타임 유형 검사 및 convert 메서드를 사용하는 Julia는 이러한 모호함을 겪지 않습니다.

PEP 0465에서 :

1d 벡터에 대한이 정의의 잘못된 점은 일부 경우 @ 비연 관적 ((Mat1 @ vec) @ Mat2! = Mat1 @ (vec @ Mat2))

때문에 특히 정의가 이러한 종류, 티카에 잘못된 결과를 생성 할 수 Dot ( . ) (회합 것으로 가정 Flat 와 같이 (기호로 평가 될 때) f 아래 ( g 제외) :

In[1]:= f=X.(y.Z);
g:=X.(y.Z)

In[3]:= Block[{
X=Array[a,{2,2}],
y=Array[b,2],
Z=Array[c,{2,2}]
},{f,g}]

Out[3]= {{(a[1,1] b[1]+a[1,2] b[2]) c[1,1]+(a[2,1] b[1]+a[2,2] b[2]) c[2,1],(a[1,1] b[1]+a[1,2] b[2]) c[1,2]+(a[2,1] b[1]+a[2,2] b[2]) c[2,2]},{a[1,1] (b[1] c[1,1]+b[2] c[2,1])+a[1,2] (b[1] c[1,2]+b[2] c[2,2]),a[2,1] (b[1] c[1,1]+b[2] c[2,1])+a[2,2] (b[1] c[1,2]+b[2] c[2,2])}}

In[4]:= SameQ@@Expand[%]
Out[4]= False

@drhagen에서 :

런타임 유형 검사 및 convert 메서드를 사용하는 Julia는 이러한 모호함을 겪지 않습니다.

이것이 바로 줄리아에게 적합한 솔루션이라고 생각하는 이유입니다. 데이터 자체가 배열과 같은 의미론 (유니버설 방송용)과 텐서 형 의미론 (가능한 축소를 위해)을 구분하도록해야합니다.

나는 결코 여기서 권위자가 아니지만 일반적인 임의 차원 컬렉션 유형 ( Array )이 내적을 수행하는 연산자를 지원해야한다고 생각하지 않습니다. 내적은 두 차원 사이에있을 수 있으므로 이항 연산자에 제공 할 수없는 추가 인수가 필요하기 때문에이 연산자는이 유형에 대해 현명하게 정의 할 수 없습니다. 모든 선형 대수 연산, inv , transpose 등도 마찬가지입니다.

선형 대수의 수학적 분야에서 작동하려면 모든 일반 선형 대수 연산자와 함수가있는 Matrix , ColumnVector 및 RowVector 세 가지 유형이 더 있어야합니다. 정상적으로 작동합니다.

이제 유형 구조가 잘 정의되었으므로 Matrix 에서 Array{2} , ColumnVector 에서 Array{1} 로의 암시 적 변환을 추가하여 사용자를 더 쉽게 만들 수 있습니다. 및 RowVector ~ Array{2} (이 항목에 대해 잘 모르겠 음), Array{2} ~ Matrix 및 Array{1} ~ ColumnVector .

위의 제안 (https://github.com/JuliaLang/julia/issues/4774#issuecomment-32705055)을 사용하면 다차원 구조의 각 차원이 중립 ( "컬렉션"/ "배열"), 위쪽 ( " 열 ") 또는 아래 ("행 ") 의미 체계. 나는 당신이 묘사하는 것이 특별한 경우라고 생각합니다.

이 일반적인 접근 방식의 장점은 데이터 또는 공간의 많은 차원이있는 계산에서도 연산자가 어떤 차원에서 작동해야하는지 명시 적으로 지정하지 않고도 올바른 작업을 수행하도록 할 수 있다는 것입니다. 적어도 Julia에서는 사용자가 유형 매개 변수를 선택하여 입력 데이터의 의미를 지정하는 것이 모든 인스턴스를 다음과 같이 호출하여 모든 작업의 ​​의미를 지정해야하는 것보다 훨씬 직관적이고 읽기 쉽다는 데 동의합니다. 차원 인덱스를 제공하는 추가 인수. 암시 적 또는 명시 적 변환은 의미가 비정상적인 방식으로 중간 스트림에서 변경되어야하는 경우 전체 차원의 일반 성과 함께 여전히 사용될 수 있습니다.

@thomasmcoffee 나는 당신의 제안을 매우 좋아합니다. 나는 몇 가지 기본 원칙 (일명 개인적인 의견)을 사용하여 DSL (오래 전에 멀리 떨어져 있음)에서 모호하게 유사한 것을 구현했습니다.

1. 구별되는 이중의 개념은 분별 적으로 일관된 의미론에 필수적입니다.
2. 매개 변수화 된 연산자 (또는 해당 문제에 대한 데이터 외부의 모든 것)를 사용하여 텐서 대수를 임시로 시행하는 것은 심미적으로 매우 불쾌합니다.

그때 제가받은 가장 큰 불만은 (그리고 시끄러 웠습니다) 3가 의미론 (중립 컬렉션 개념 추가)이 해결하는 불편 함의 종류에 대한 것입니다. 좋은! 그 아이디어는 나에게 결코 떠오르지 않았지만, 당신이 그것을 밖으로 내놓았 기 때문에 지금은 너무나 의미가 있습니다. 저는 그러한 시스템을 정말로 사용하고 싶습니다. 실제 작업을 의미합니다. Julia가 이것을 수용 할 수 있다면 좋을 것입니다!

여러분이 설명하는 것은 일반 텐서입니다. 다른 두 가지 사용 사례 (컬렉션 및 선형 대수)가 훨씬 더 일반적이기 때문에 이것이 표준 라이브러리에있는 것을 정당화 할만큼 충분히 일반적인 사용 사례라고 생각합니다. 그러나 원활하게 통합 될 수 있다면 지원할 것입니다. 벡터 행렬 곱셈, 스칼라 배열 곱셈, 배열 배열에 하나의 배열 추가 분배 등과 같이이 시스템에서 볼 수있는 일반적인 작업에 대한 몇 가지 예를 제공 할 수 있습니까?

나는 당신이 맞다고 생각합니다 David. 우리는 실제로 두 가지 사용 사례에 대해 이야기하고 있습니다.

Linear Algebra의 하위 집합은 대부분의 사람들에게 가장 일반적으로 필요합니다.
말하다. 그곳에서도 나는 v와 v '를 구별하는 것을 옹호합니다.

내가 정말로 원하는 것은 (여기에 탐욕에 대한 공개 삽입) Tensors with
일류 (또는 종가) 상태 ... 기본 속도에 가깝습니다 (제한적인 경우,
선형 대수 성능과 비교) 쉬운 구문으로 과장되지 않음
입력 문제, 데이터에 인코딩 된 공 / 반공 변성이 아니라
연산자. 데이터 의미를 정의하면 작업은
그냥 일이야. Tensoral Duck 타이핑.

아마도 텐서와 TDT는 코어가 아닌 패키지에 속합니다.
상대적인 인기의 근거. 그러나 Julia 선언처럼
독립은 줄리아는 탐욕에서 태어 났다고 말합니다. Gordon Gecko가 말했듯이
탐욕이 좋다. :)
2014 년 3 월 21 일 오전 3:14에 "David Hagen" [email protected]이 작성했습니다.

여러분이 설명하는 것은 일반 텐서입니다. 나는 그것이
표준 라이브러리에있는 것을 정당화하기에 충분히 일반적인 사용 사례입니다.
다른 두 가지 사용 사례 (컬렉션 및 선형 대수)는 훨씬 더
흔한. 그러나 원활하게 통합 될 수 있다면 지원할 것입니다.
몇 가지 일반적인 작업이 어떻게 보일지에 대한 몇 가지 예를 들어 주시겠습니까
이 시스템에서 벡터 행렬 곱셈, 스칼라 배열
곱셈, 하나의 배열의 추가를 배열의 배열에 분배
배열 등?

이 이메일에 직접 답장하거나 Gi tHub에서 확인 하세요.
.

풍부한 유형의 제품군을 고려할 때 원활한 통합이 확실히 가능하다고 생각합니다. 위의 Toivo의 https://github.com/JuliaLang/julia/issues/4774#issuecomment -32693110을 확장하면 다음과 같이 개념적으로 시작할 수 있습니다.

immutable AbstractTensorArray{T, N, UPMASK, DOWNMASK} <: AbstractArray{T, N}
    A::AbstractArray{T, N}
end
# where !any(UPMASK & DOWNMASK)

typealias AbstractColumnVector{T} AbstractTensorArray{T, 1, [true], [false]}
typealias AbstractRowVector{T} AbstractTensorArray{T, 1, [false], [true]}
typealias AbstractMatrix{T} AbstractTensorArray{T, 2, [false, true], [true, false]}

(현재 AbstractMatrix{T} 단순히 AbstractArray{T, 2} 별칭을 지정합니다. 잠재적으로 여기에서 다른 이름을 사용할 수 있습니다.)

여기에서 다음 구현은 논리적으로 보입니다.

1. 일반화 된 transpose 메서드는 차원과 해당 UPMASK 및 DOWNMASK 인덱스를 다시 정렬 한 후 UPMASK와 DOWNMASK를 교환합니다. 중립 치수는 영향을받지 않습니다.
2. 모든 AbstractArray{T, N} 하위 유형은 일반적으로 기본적으로 텐서 작업에서 해당하는 대체 AbstractTensorArray{T, N, [..., false, true, false, true], [..., true, false, true, false]} 하위 유형으로 변환됩니다. 이것은 벡터와 행렬에 대한 Julia의 특별한 배열 구문의 기존 의미를 보존합니다.
3. AbstractTensorArray 대한 생성자 메서드 (예 : array )는 중립 차원을 생성하는 데 사용되며 다른 AbstractTensorArray s (또는 변환 가능한 유형)를 결합하여 결합 된 AbstractTensorArray 를 생성 할 수 있습니다 AbstractTensorArray .

@drhagen 의 예를 고려하십시오.

벡터 행렬 곱셈, 스칼라 배열 곱셈

c = 1               # Int
v = [1, 2]          # Array{Int, 1}
M = [[1, 2] [3, 4]] # Array{Int, 2}

# scalar-array
c * M               # UNCHANGED: *(Int, Array{Int, 2}) => Array{Int, 2}

# matrix-vector
M * v               # *(Array{Int, 2}, Array{Int, 1}) => *(Matrix{Int}, ColumnVector{Int}) => ColumnVector{Int}

# vector-matrix
v' * M              # transpose(Array{Int, 1}) => transpose(ColumnVector{Int}) => RowVector{Int}
                    # *(RowVector{Int}, Array{Int, 2}) => *(RowVector{Int}, Matrix{Int}) => RowVector{Int}

# (1-array)-(2-array)
v .* M              # UNCHANGED: .*(Array{Int, 1}, Array{Int, 2}) => Array{Int, 2}

( Matrix 의 AbstractMatrix 정의에 해당하는 정의와 함께 Matrix 사용)

하나의 어레이 추가를 어레이 어레이에 분배

이것은 의미 상 벡터 배열에 하나의 벡터 추가, 행렬 배열에 하나의 행렬 추가 등을 의미합니다.

# vector-(vector-array)
ws = array([1, 2], [3, 4])
                    # TensorArray{Int, 2, [false, true], [false, false]}
v + ws              # +(Array{Int, 1}, TensorArray{Int, 2, [false, true], [false, false]}) => +(ColumnVector{Int}, TensorArray{Int, 2, [false, true], [false, false]}) => TensorArray{Int, 2, [false, true], [false, false]}
# => array([2, 4], [4, 6])

# array-(vector-array)
u = array(1, 2)     # TensorArray{Int, 1, [false], [false]}
u + ws              # +(TensorArray{Int, 1, [false], [false]}, TensorArray{Int, 2, [false, true], [false, false]}) => TensorArray{Int, 2, [false, true], [false, false]}
# => array([2, 3], [5, 6])
# alternatively:
v .+ ws             # .+(Array{Int, 1}, TensorArray{Int, 2, [false, true], [false, false]}) => TensorArray{Int, 2, [false, true], [false, false]}
# => array([2, 3], [5, 6])
# same effect, but meaning less clear:
v .+ M              # UNCHANGED: .+(Array{Int, 1}, Array{Int, 2}) => Array{Int, 2}
# => [[2, 4] [4, 6]]

# matrix-(matrix-array)
Ns = array([[1, 2] [3, 4]], [[5, 6] [7, 8]])
                    # TensorArray{Int, 2, [false, false, true], [false, true, false]}
M + Ns              # +(Array{Int, 2}, TensorArray{Int, 2, [false, false, true], [false, true, false]}) => +(Matrix{Int}, TensorArray{Int, 2, [false, false, true], [false, true, false]}) => TensorArray{Int, 2, [false, false, true], [false, true, false]}
# => array([[2, 4] [6, 8]], [[6, 8] [10, 12]])

최종 결과 x'M*w1*v, x'M*w2*v, ... 대해 여러 가지 2 차 형식 x'M*w1, x'M*w2, ... 으로 벡터 v 배율을 조정하는 이전 예제를 고려해보십시오.

x = v
x' * M * ws * v     # *(RowVector{Int}, Array{Int, 2}) => *(RowVector{Int}, Matrix{Int}) => RowVector{Int}
                    # *(RowVector{Int}, TensorArray{Int, 2, [false, true], [false, false]}) => TensorArray{Int, 1, [false], [false]}
                    # *(TensorArray{Int, 1, [false], [false]}, Array{Int, 1}) => *(TensorArray{Int, 1, [false], [false]}, ColumnVector{Int}) => TensorArray{Int, 1, [false, true], [false, false]}
# => array([27, 54], [59, 118])

이 개념적 구현에서는 AbstractArray 가 그대로 남아 있으므로 AbstractTensorArray 가 유형 계층 구조에서 자체 "공간"을 형성한다고 가정했습니다. 전체 AbstractArray 패밀리가 단순히 AbstractTensorArray 로 대체되면 상황이 단순화 될 수 있지만 이는 또 다른 논의입니다.

양자 물리학에서 무언가를위한 패키지의 맥락에서, 나는 내 자신의 텐서 유형 (실제로는 둘 이상)을 정의하는 데 놀아왔다. 처음에는 두 가지 유형 (위쪽 및 아래쪽, 수신 및 발신, 공변 및 반반 변성)으로 오는 인덱스에 대한 개념도있었습니다.이 정보는 유형의 필드 또는 유형 매개 변수. 잠시 후 나는 이것이 매우 번거 롭다고 결정했습니다. 텐서의 인덱스를 벡터 공간 (내가 이미했던)에 연관시키고이 벡터 공간이 다른 이중을 갖도록하는 것이 훨씬 쉽습니다. 실제로 벡터 공간이란 공간의 차원과 이중 여부를 감싸는 단순한 줄리아 유형을 의미합니다. 텐서 인덱스가 일반 벡터 공간에 연결되어 있으면 업 인덱스이고 이중 인덱스에 연결되어 있으면 다운 인덱스입니다. 구별이없는 텐서 / 배열로 작업하고 싶습니까? 일반 벡터 공간과 이중 공간을 구별하지 않는 다른 벡터 공간 유형을 정의하기 만하면됩니다.

이 제안에서는 서로 이중 인 벡터 공간과 관련된 텐서 인덱스 만 계약 할 수 있습니다. ctranspose (= Hermitian conjugation)는 모든 인덱스의 벡터 공간을 이중으로 매핑합니다 (행렬의 경우 인덱스의 순열 및 고차 텐서에 대한 선호 정의와 함께) 등.

물론, 정상적인 전치와 복합 활용은이 설정에서 실제로 잘 정의되지 않습니다 (즉, 이들은 기본 독립적 개념이 아닙니다).

최소한 다음과 같이 보입니다.

immutable Space
    dim::Int
    dual::Bool
end
Space(dim::Int)=Space(dim,false) # assume normal vector space by default
dual(s::Space)=Space(s.dim,!s.dual)

matrix=Tensor((Space(3),dual(Space(5))))
# size is no longer sufficient to characterise the tensor and needs to be replaced by space
space(matrix) # returns (Space(3),dual(Space(5))) 
space(matrix') # returns (Space(5),dual(Space(3)))

물론 Space를 지속적으로 작성할 필요가 없도록 몇 가지 구문을 발명 할 수 있습니다. up과 down 인덱스 등을 구분하지 않는 텐서를 갖기 위해 dual (s) == s 인 다른 공간 유형을 만들 수 있습니다. 그러나 물론 이것이 모든 것을 깨지 않고 Julia의 표준 배열 유형에 여전히 내장 될 수있는 방법은 없습니다 ...

저는 항상 공학 / 물리학에서 텐서를 사용하는 방법과 수학적 소프트웨어 프로그램에서 텐서를 처리하는 방법 사이에 밀접한 관계가없는 이유가 궁금했습니다. 주제에 대한 흥미로운 스택 교환 대화를 찾았습니다 ... http://math.stackexchange.com/questions/412423/differences-between-a-matrix-and-a-tensor. 여기도 좋은 참고 게시물이었습니다.
http://www.mat.univie.ac.at/~neum/physfaq/topics/tensors

저는 매일의 과학 컴퓨팅에 Matlab을 많이 사용하지만 Julia에서는 초보자입니다. 여기에서 고차원 배열 곱셈 및 전치 또는 기타 유사한 배열 작업에 대한 많은 논의가 있음을 알 수 있습니다. http://www.mathworks.com/matlabcentral/fileexchange/8773-multiple-matrix-multiplications--with-array-expansion-enabled를 살펴볼 것을 제안합니다

기본적으로 @drhagen 이 이전 게시물에서 언급 한 것과 유사한 구문을 따릅니다. 예를 들어 array_product (A, B, inner_A_dim = [1, 2], inner_B_dim = [3, 4]) 는 배열 A와 B 사이의 제품입니다. 주어진 내부 차원.

이것은 선택한 차원에 곱셈 또는 전치 연산을 적용 할 수있는 하나의 Matlab 패키지입니다. Matlab에서 이러한 작업을 구현하는 방법에 대한 설명서가 패키지에 있지만 수학 이론은 다른 언어에도 적용되어야한다고 생각합니다. 그들의 아이디어는 For 루프 사용을 피하고 대부분 배열 재구성 등에 의존하여 배열 작업을 구현하는 것입니다. 따라서 Matlab에서는 매우 빠릅니다. Julia가 벡터화 작업을 더 좋아하는지 아니면 비 벡터화 작업을 더 좋아하는지 모르겠습니다 (나중의 작업 인 것 같습니다). 코어가 지원한다면 벡터화 연산이 고차원 배열 연산에 유리하다고 생각합니다. 이 단계에서 이런 종류의 배열 작업을 진심으로 고려해야 할 것입니다.

참고로 : INV 작업을위한 Matlab의 또 다른 유사한 구현은 다음과 같습니다. http://www.mathworks.com/matlabcentral/fileexchange/31222-inversion-every-2d-slice-for-arbitrary-multi-dimension-array

또한 2005 년 Matlab 어레이 운영 지원 패키지 출시 이후 다운로드 기록은 현재까지 높은 수준으로 유지되고 있습니다. 실제 경험과 마찬가지로 배열 작업은 물리학 및 기타 영역에서 매우 자주 사용됩니다. 줄리아가 임의의 크기로 배열을 운영하는 유사한 기능을 가지고 있다면 게임이 매우 흥미로워 질 것입니다!

@alanedelman 의 제안 된 솔루션에 대한 또 다른 투표. 여기에 동기를 부여하는 예가 있습니다.

현재 행 슬라이스는 2d 배열이고 열 슬라이스는 1d 배열입니다. 이상하게 비대칭이고 추합니다.

julia> A = randn(4,4)
4x4 Array{Float64,2}:
  2.12422    0.317163   1.32883    0.967186
 -1.0433     1.44236   -0.822905  -0.130768
 -0.382788  -1.16978   -0.19184   -1.15773
 -1.2865     1.21368   -0.747717  -0.66303

julia> x = A[:,1]
4-element Array{Float64,1}:
  2.12422
 -1.0433
 -0.382788
 -1.2865

julia> y = A[1,:]
1x4 Array{Float64,2}:
 2.12422  0.317163  1.32883  0.967186

특히, 그것은 내가 행에 열을 곱하고 숫자를 추출 할 수 없다는 것을 의미합니다.

julia> dot(y[:],x)
2.4284575954571106
julia> (y*x)[1]
2.42845759545711

'* 를 특수 연산자로 지정하지 않는 한 일관된 제안이 아닙니다. x'*y 와 (x')*y 는 같은 의미가 아니기 때문에 매우 모호합니다. 더욱이 곱셈을 비연 관적으로 만들 것입니다.

나는 x_y '와 y'_x의 어려움을 이해합니다. 치료하는 것이 더 나을 수 있습니다
예를 들어 dot ()을 사용하여 내부 및 외부 제품을 별도의 작업으로 사용합니다. (혹시
또한 cdot를 사용합니까?)

그러나 첫 번째를 따라 슬라이스를 갖는 것에 찬성하는 주장은 무엇입니까?
차원은 차원이 슬라이스와 다른 객체를 반환합니다.
두 번째 차원? 일관성을 위해 슬라이스 할 때마다
결과 개체의 크기는 1만큼 감소해야합니다.

2014 년 7 월 16 일 수요일 오후 8시 17 분, Stefan Karpinski [email protected]
썼다 :

'*를 특수 연산자로 지정하지 않으면 일관된 제안이 아닙니다.
x'_y와 (x ') _ y는 같은 의미가 아니기 때문에 꽤 모호합니다.
더욱이 곱셈을 비연 관적으로 만들 것입니다.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.
https://github.com/JuliaLang/julia/issues/4774#issuecomment -49254346.

마들렌 우델
전산 및 수학 공학 박사 과정
스탠포드 대학교
www.stanford.edu/~udell

@madeleineudell , 동의하지만 다른 문제입니다. # 5949를 참조하십시오. 그 문제는 종결 된 것 같지만 명확한 합의 나 결론이 있었던 기억이 없습니다.

배열보기로 전환하면 해당 방향을 탐색하기가 더 쉬워집니다. 특히 slice(A, i, :) 라고 말하면 원하는 동작을 얻을 수 있습니다. (지금은 그렇게되지만 더 느린 유형 인 SubArray를 도입해야합니다.)

순전히 수학적 관점에서, 여기에 제시된 모든 문제는 배열이 의미하는 것과 벡터 / 텐서 / 행렬이 의미하는 것의 융합 (및 혼동)에서 비롯됩니다. 개념적으로 배열은 단순히 목록 (또는 n 차원 배열의 경우 목록 목록)입니다. 따라서 배열 곱셈, 전치 등과 같은 연산에 대한 자연적인 사양은 없습니다. 순열, 요소 별 연산, 축별 연산 (평균, 중앙값 등)과 같은 함수는 의미가 있으며 a에서 고유하게 정의 될 수 있습니다. 자연스러운 방식으로 내적과 같은 작업은 할 수 없습니다.

위에서 언급했듯이 벡터와 텐서는 기하학적 객체이며 배열을 사용하여 표현할 수는 있지만 이러한 표현은 표현하는 수학적 객체와 동일한 구조의 풍부함을 포함하지 않습니다. 1 차원 배열의 전치는 작동하지 않습니다. 벡터의 전치는 이중입니다. 2 차원 배열의 전치는 차원의 순열로 고유하고 자연스럽게 정의 될 수 있지만 일반적으로 텐서에는 해당되지 않습니다. 자연 사례는 순위 (1,1) 텐서 (일명, 행렬)에 대해 유지됩니다. rank (2,0) tensor는 rank (0,2) tensor로 전치합니다. 다시 말하지만 텐서를 배열로 취급하면 텐서를 텐서로 만드는 기하학적 정보가 손실됩니다.

이것은 내적과 같은 연산을 정의 할 때 중요합니다. 내적은 특정 기하학적 의미 (두 번째 벡터에 의해 정의 된 이중 공간에 한 벡터의 투영)를 가지고 있으므로 내적의 일관된 정의를 위해서는 벡터에 포함 된 기하학적 정보를 보존해야합니다. 특정 가정을 사용하면 배열을 사용할 수 있고 여전히 대부분의 사용 사례를 다룰 수 있지만 이러한 가정은 (이 스레드의 다양한 제안에서 볼 수 있듯이) 지저분하고 실제로 텐서의 풍부한 구조를 필요로하는 모든 사람에게 일을 더 어렵게 만듭니다. .

따라서 더 풍부한 AbstractTensor 유형을 포함하기위한 thomasmcoffee의 제안에 찬성하는 강력한 투표라고 생각하십시오. 개인적으로 선호하는 것은 전치 및 내적과 같은 연산이 배열에 대해 정의되지 않은 것입니다.하지만 대부분의 사람들이 그 관점을 공유하지 않을 것이라고 생각하므로 최소한 필요한 경우 진정한 텐서를 생성 할 수있는 기능이 필요합니다.

이 관점의 실질적인 의미는 배열이 텐서의 하위 집합으로 식별되어야하고 1 차원 배열을 전치하면 DualVector 또는 오류가 발생해야한다는 것입니다. 내 견해는 이것이 복소수를 제공하는 실수에 대한 연산과 유사하다는 것입니다.

내 관점은 (다차원) 데이터 컨테이너 인 일반 AbstractArray 제품군이 모든 기술 프로그래밍 언어에서 없어서는 안될 부분이 될만큼 충분히 일반적이라는 것입니다. 엄격한 수학적 규칙을 따르는 텐서는 내가 그것을 매우 중요하게 생각하더라도 전용 패키지를위한 좋은 개체입니다. 사실, https://github.com/Jutho/TensorToolbox.jl 에서 @jdbates 가 지정한 줄을 따라 작업하고 있습니다 . 지금까지 문서화되지 않았으며 대부분 테스트되지 않았습니다. 나는 양자 많은 신체 물리학에서 개인적으로 필요한 것들을 위해 그것을 썼지 만, 텐서 작업에 관심이있는 더 큰 수학자 및 물리학 자 커뮤니티에 유용 할만큼 충분히 일반적이고 확장 가능한 방식으로 구성되기를 바랍니다.

세부 사항을 제공하기 위해 (JuliaQuantum 포럼에서 복사) : Julia의 AbstractArray 유형과 독립적 인 텐서에 대한 새로운 유형 계층을 정의하기로 결정했습니다 (기본 Tensor는 배열의 래퍼 일 뿐임). 이 유형 계층은 약간 더 공식적인 방식으로 작동해야합니다. 텐서 인덱스는 벡터 공간 (이후 인덱스 공간이라고 함)과 연관되며, 텐서 인덱스가 연관되는 벡터 공간 유형이 이중과 다른 경우 이는 공변 및 반 변성 인덱스를 구분하는 텐서에 해당합니다.

따라서 패키지의 첫 번째 부분은 벡터 공간을 정의하는 추상적 인 부분입니다. 여기에서 Julia 객체의 유형 계층을 벡터 공간의 수학적 계층과 일치시킵니다. 일반 벡터 공간 V는 V에 대한 일반 선형 그룹의 표현 이론, 즉 V 자체 (기본 표현), conj (V), 이중 (V) 및 이중 (conj (V))에 해당하는 네 가지 유형으로 제공됩니다. 실수 벡터 공간의 경우 conj (V) = V이고 반 변성 및 공변 벡터에 해당하는 V 및 이중 (V) 만 있습니다. 그런 다음 내부 곱 공간이 있으며 계층 구조의 최상위 수준에는 표준 유클리드 내부 곱 (즉, 직교 기저)을 갖는 내부 곱 공간 인 유클리드 공간이 있습니다. 물리학에서 다른 섹터로 분해되는 벡터 공간에 대해 생각하는 것도 유용합니다. 즉, 대칭 동작의 축소 불가능한 표현에 의해 등급이 매겨집니다.

텐서는 일부 기본 벡터 공간의 텐서 곱 (부분 공간)에 살고있는 객체입니다. 그러나 인덱스 공간의 텐서 제품 공간에 사는 객체 인 표준 Tensor를 제외하고, 예를 들어 irreps에 의해 등급이 매겨진 공간의 텐서 곱의 불변 섹터에 사는 텐서를 만들 수 있습니다. 동일한 공간의 텐서 곱, ... 하나는 페르미온 벡터 공간을 인덱스 공간으로 가질 수 있으며, 이는 텐서 인덱스의 순열이 패리티 섹터 등에 따라 특정 부호 변화를 유도한다는 것을 의미합니다.

그런 다음 텐서에 대해 정의 된 특정 연산이 있어야합니다. 그 중 가장 중요한 것은 축소 텐서이지만, 예를 들어 직교 분해 (단일 값 분해) 등입니다. 마지막으로 하나의 텐서를 다른 텐서에 매핑하는 선형 맵이 있어야합니다. 일반적으로 행렬로 완전히 인코딩하는 것이 아니라 반복적 방법 (Lanczos 등)에서 사용하기 위해 행렬 벡터 곱을 효율적으로 계산할 수 있다는 점에서 특별한 유형이 필요합니다. 지금까지 내 두 개의 기존 패키지 (TensorOperations.jl 및 LinearMaps.jl)는 표준 배열에 대해이 기능을 구현합니다. 구축중인 텐서 도구 상자는 새로운 AbstractTensor 계층에 대해 오버로드 / 재정의합니다.

이 패키지가 더 넓은 물리 / 수학 커뮤니티에도 유용 할 정도로 충분히 일반적 이길 바랍니다. 예를 들어, 매니 폴드 작업을위한 패키지를 생성하는 누군가가 오면 그는 TangentSpace 벡터 공간을 추상 InnerProductSpace의 부분 공간으로 정의 할 수 있으며, 그런 다음 몇 개의 탄젠트 및 코탄젠트 공간의 텐서 곱에 사는 텐서를 즉시 생성 할 수 있습니다. 사실 저는 벡터 공간을 정의하는 부분을 별도의 패키지로 분할하여 수학적 구조 / 객체를 정의하는 패키지로 성장할 수 있도록 생각하고 있습니다.

끝으로, 표준 줄리아 갖는 상호 운용성이 호출에서 유래 tensor 의 표준 Array 타입의 객체로 랩하는 Tensor 형의 공간으로 관련된 인덱스와 CartesianSpace 이것은 유클리드 곱을 사용하는 표준 실수 벡터 공간 R ^ n으로, 공변 인덱스와 반반 인덱스 사이에 차이가 없습니다. 나는 이것이 표준 Julia Array가 무엇인지 가장 잘 수반한다고 생각합니다.

@JeffBezanson , 배열을 텐서의 하위 집합으로 취급하는 것과 관련하여 양가 적입니다. 그런 식으로 정보가 손실되지는 않지만 동시에 배열에 대해 여러 해석이 가능하며 텐서 해석이 항상 (또는 일반적으로) 의미가있는 것은 아닙니다. 이미지 고려 : 이미지는 (일반적으로 2d) 매니 폴드에서 벡터 값 필드로 생각할 수 있습니다. 해당 필드를 직사각형 그리드로 제한하면 당연히 3D 배열을 사용하여 표현하고 싶은 구조가 제공됩니다. 그러나 실제로 이것은 그리드 점의 공간에서 {R, G, B} 벡터 공간으로의 매핑 일 뿐이므로 처음 두 차원 (그리드의 x 및 y 레이블)의 기하학적 의미는 3 차원의 기하학적 의미 (사실상 벡터).

나는 텐서 역학을 별도의 패키지로 분리 하라는 @Jutho 의 제안에 반대하지 않습니다. 그는 완전한 텐서 메커니즘을 필요로하는 사용자 수가 단순한 배열 작업을 원하는 사용자 수보다 훨씬 적다는 것이 옳을 것입니다. 여기서 우리가 실제로 묻고 자하는 질문은 "선형 대수가 어느 영역에 속해야 하는가?"입니다.

선형 대수의 기계는 텐서 대수의 기계의 실질적인 하위 집합이므로 적어도 후자를 구현하지 않고 전자를 구현하는 것은 의미가 없습니다. v'M과 같은 연산은 공변 및 반 변성 벡터의 개념이있는 경우 더 간결하고 일관되게 표현되지만, 이미 일반적인 텐서 연산을 향한 대부분의 방법을 제공합니다.

나는 이것이 개념적으로 복소수를 반환하는 실수 연산과 유사하다는 데 동의합니다.

이미지 고려 : 이미지는 (일반적으로 2d) 매니 폴드에서 벡터 값 필드로 생각할 수 있습니다. 해당 필드를 직사각형 그리드로 제한하면 당연히 3D 배열을 사용하여 표현하고 싶은 구조가 제공됩니다. 그러나 실제로 이것은 그리드 점의 공간에서 {R, G, B} 벡터 공간으로의 매핑 일 뿐이므로 처음 두 차원 (그리드의 x 및 y 레이블)의 기하학적 의미는 3 차원의 기하학적 의미 (사실상 벡터).

이것이 전체 메시지를 다루거나 제거하지는 않지만 https://github.com/timholy/Images.jl/pull/135 는 이미지에 대한이 아이디어를 구현하기 위해 노력하고 있습니다. 나는 이것이 또한 프로젝트에 사용하려는 색상 구조 텐서를 쉽게 다룰 수 있기를 바랍니다.

2014 년 8 월 23 일 20:36에 jdbates [email protected] 은 다음과 같이 썼습니다.

@JeffBezanson , 배열을 텐서의 하위 집합으로 취급하는 것과 관련하여 양가 적입니다. 그런 식으로 정보가 손실되지는 않지만 동시에 이미지에 대한 여러 해석이 가능하며 텐서 해석이 항상 (또는 일반적으로) 의미가있는 것은 아닙니다. 이미지 고려 : 이미지는 (일반적으로 2d) 매니 폴드에서 벡터 값 필드로 생각할 수 있습니다. 해당 필드를 직사각형 그리드로 제한하면 당연히 3D 배열을 사용하여 표현하고 싶은 구조가 제공됩니다. 그러나 실제로 이것은 그리드 점의 공간에서 {R, G, B} 벡터 공간으로의 매핑 일 뿐이므로 처음 두 차원 (그리드의 x 및 y 레이블)의 기하학적 의미는 3 차원의 기하학적 의미 (사실상 벡터).

텐서가 배열을 대체하지 않는다는 데 동의합니다. 위의 예는 실제로 다른 수학적 구조 (즉, 벡터 번들 또는보다 일반적으로 텐서 번들)이며, 매니 폴드 좌표에 대한 그리드와 벡터 공간 부분에 대한 기준을 선택하여 다차원 배열로 표현할 수도 있습니다. 따라서 실제로 좌표 독립적 / 기초 독립적 방식으로 잘 정의되어 있지만 (좌표계 또는 기저를 선택한 후) 다차원 배열로 표현할 수있는 다른 수학적 객체 / 구조를 가질 수 있습니다. 따라서 다차원 배열은 확실히 텐서를 나타내는 것으로 제한되지 않습니다. 다른 방법도 실패합니다. 모든 텐서가 다차원 배열을 사용하여 편리하게 표현하는 것은 아니기 때문입니다. 이는 텐서 곱 공간에 포함 된 벡터 공간의 개별 기저 벡터의 가능한 모든 조합을 직접 곱하여 얻은 제품 기저로 알려진 특정 기저를 사용하는 경우에만 해당됩니다. 예를 들어 텐서 곱 공간의 대칭 불변 부분 공간에서 텐서를 사용할 때 이러한 표현은 더 이상 불가능하며 텐서가 다음과 같이 표현되는 것과 관련하여 전체 공간에 대해 다른 기준을 정의해야합니다. 긴 1 차원 숫자 목록.

나는 텐서 역학을 별도의 패키지로 분리 하라는 @Jutho 의 제안에 반대하지 않습니다. 그는 완전한 텐서 메커니즘을 필요로하는 사용자 수가 단순한 배열 작업을 원하는 사용자 수보다 훨씬 적다는 것이 옳을 것입니다. 여기서 우리가 실제로 묻고 자하는 질문은 "선형 대수가 어느 영역에 속해야 하는가?"입니다.

선형 대수의 기계는 텐서 대수의 기계의 실질적인 하위 집합이므로 적어도 후자를 구현하지 않고 전자를 구현하는 것은 의미가 없습니다. v'M과 같은 연산은 공변 및 반 변성 벡터의 개념이있는 경우 더 간결하고 일관되게 표현되지만, 이미 일반적인 텐서 연산을 향한 대부분의 방법을 제공합니다.

나는 이것이 개념적으로 복소수를 반환하는 실수 연산과 유사하다는 데 동의합니다.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.

배열에 대해 여러 가지 해석이 가능하며 텐서 해석이 항상 (또는 일반적으로) 의미가있는 것은 아닙니다. 이미지 고려 : 이미지는 (일반적으로 2d) 매니 폴드에서 벡터 값 필드로 생각할 수 있습니다. 해당 필드를 직사각형 그리드로 제한하면 당연히 3D 배열을 사용하여 표현하고 싶은 구조가 제공됩니다. 그러나 실제로 이것은 그리드 점의 공간에서 {R, G, B} 벡터 공간으로의 매핑 일 뿐이므로 처음 두 차원 (그리드의 x 및 y 레이블)의 기하학적 의미는 3 차원의 기하학적 의미 (사실상 벡터).

https://github.com/JuliaLang/julia/issues/4774#issuecomment -38333295의 개념적인 AbstractTensorArray 제안에서 배열 유사 및 텐서를 허용하여 캡처하려는 것은 이러한 종류의 구별이었습니다. 같은 치수. 이 계획에 따라 귀하의 예를 다음과 같이 나타낼 것으로 기대합니다.

AbstractTensorArray{Uint8, 3, [false, true, false], [true, false, false]}

따라서 x, y 및 RGB 크기는 각각 "아래", "위"및 "중립"이됩니다. 기하학적 연산 (예 : 아핀 변환)은 배열과 같은 방식으로 RGB 값을 매핑하면서 텐서와 같은 방식으로 그리드 좌표 차원을 처리 할 수 ​​있습니다. (나중에 RGB 값을 기하학적으로 처리하려면 해당 목적을 위해 마스크를 명시 적으로 변경해야하지만 (a) 두 가지 다른 기하학적 연산이의 서로 다른 부분 공간에 적용되는 것이 일반적이지 않다고 생각합니다. 동일한 데이터 테이블, (b)이 상황에서 명시 적 변환은 아마도 코드의 명확성을 _ 향상시킬 것입니다.)

@Jutho가 언급하는 켤레 표현을 고려하지 않았지만 복잡한 공간에 대해 동일한 마스킹 접근 방식을 더 확장하여이 일반화를 처리 할 수있는 것 같습니다.

여기서 우리가 실제로 묻고 자하는 질문은 "선형 대수가 어느 영역에 속해야 하는가?"입니다.

배열 유사 및 텐서 유사 연산이 함께 작동하는 방식에 대한 설계가 정해지면 선형 대수에 대한 엔터티는 위에서 사용한 별칭과 같은 특수 사례로 정의 할 수 있으므로 순수한 선형 대수 사용자가 전체 일반화 된 텐서 계층이 필요할 때까지 (하지만 필요한 경우 다시 작성할 필요가 없습니다). 그래서 나는 모든 것을 Base에 넣는 데 아무런 문제가 없을 것입니다.

따라서 x, y 및 RGB 크기는 각각 "아래", "위"및 "중립"이됩니다. 기하학적 연산 (예 : 아핀 변환)은 배열과 같은 방식으로 RGB 값을 매핑하면서 텐서와 같은 방식으로 그리드 좌표 차원을 처리 할 수 ​​있습니다. (나중에 RGB 값을 기하학적으로 처리하려면 해당 목적을 위해 마스크를 명시 적으로 변경해야하지만 (a) 두 가지 다른 기하학적 연산이의 서로 다른 부분 공간에 적용되는 것이 일반적이지 않다고 생각합니다. 동일한 데이터 테이블, (b)이 상황에서 명시 적 변환은 아마도 코드의 명확성을 향상시킬 것입니다.)

여기서 뭔가를 섞는 것 같아요. 위의 논의에서 x 및 y 좌표는 반드시 평평한 공간이 아닌 임의의 곡선 매니 폴드상의 좌표에 대응할 수 있기 때문에 벡터 공간 해석을 수행하지 않는다고 실제로 설명했습니다. 벡터 해석이 주어진 것은 RGB 치수 였지만, 색 공간도 다소 곡선이라는 것을 기억하는 것처럼 (이미지 처리에 적절한 배경이 없음) 이것이 실제로 최선의 선택이 아닐 수도 있습니다. 또한 도메인 (x 및 y)이 벡터 공간을 형성하는 경우에도 x와 y가 위아래로 나타나는 이유는 무엇입니까? 아니면 이것이 바로 표기법의 예일까요?

어쨌든 저는 TensorToolbox.jl을 사용하여 어떤 종류의 매개 변수 또는 마스크로 공변 및 반 변성 인덱스를 표시했지만 곧 완전한 악몽이 되었기 때문에 모든 텐서가 일부 벡터 공간의 요소 인 표현으로 전환했습니다. 작업을 수행하려면 배열 작업을 수행 할 때 크기가 일치하는지 확인해야하는 것처럼 공백이 일치하는지 확인해야합니다.

x 및 y 좌표는 벡터 공간 해석을 수행하지 않았습니다.

죄송합니다. "직사각형 격자"를 너무 많이 읽었습니다. --- @jdbates 가 그가 말한 것을 정확히 의미한다고 생각합니다. 그러나 우리는 단지 내적을 일반화 된 내적로 대체하는 것에 대해 이야기하는 것이 아닙니까? (오해하면 용서 해주세요, 거의 모든 시간을 유클리드 공간에서 보냅니다 :-)

모든 텐서는 일부 벡터 공간의 요소입니다.

좋은 아이디어처럼 보입니다 --- 사용자에게 어떻게 작동하는지에 대한 몇 가지 예를보고 싶습니다 (코드를 많이 읽지 않았습니다).

이 문제에 대한 새로운 제안이 있습니다.

(1) APL 스타일 슬라이싱.

size(A[i_1, ..., i_n]) == tuple(size(i_1)..., ..., size(i_n)...)

특히, 이것은 "단일 슬라이스"(즉, 인덱스가 스칼라 또는 0 차원 인 슬라이스)가 항상 삭제되고 M[1,:] 및 M[:,1] 가 하나가 벡터가 아닌 벡터라는 것을 의미합니다. 다른 하나는 행 행렬이거나 다른 구별입니다.

(2) 벡터 및 행렬에 대해 Transpose 및 ConjTranspose 래퍼 유형을 도입합니다. 즉, 다음과 같습니다.

immutable Transpose{T,n,A<:AbstractArray} <: AbstractArray{T,n}
    array::A
end
Transpose{T,n}(a::AbstractArray{T,n}) = Transpose{T,n,typeof(a)}(a)

벡터와 행렬에 대해 이러한 작업을 수행 할 수있는 모든 적절한 방법이 있습니다. 일반적인 전치가 임의의 차원에 대해 무엇을 의미해야하는지 명확하지 않기 때문에 벡터와 행렬에 대해서만 작동하도록 제한 할 수 있습니다 (차원을 반전하는 것이 유혹적 임에도 불구하고). 당신이 쓸 때 a' 당신이 얻을 ConjTranspose(a) 마찬가지로 및 v.' 생산 Transpose(a) .

(3) 다음과 같이 (결합) 전치 벡터 및 행렬에 대한 다양한 특수 방법을 정의합니다.

*(v::Transpose{T,1}, w::AbstractVector) = dot(v.array,w)
*(v::AbstractVector, w::Transpose{T,1}) = [ v[i]*w[j] for i=1:length(v), j=1:length(w) ]

모든 끔찍한 At_mul_B 함수와 특수 구문 분석을 lazy (conjugate) 전치 구성으로 대체 한 다음 Transpose 및 ConjTranspose 유형에 대한 디스패치를 ​​포함합니다.

(4) 인수가 동일한 차원의 스칼라 또는 배열 인 경우 브로드 캐스팅 작업을 제한합니다. 따라서 현재 표시된대로 작동하는 다음은 실패합니다.

julia> M = rand(3,4);

julia> M./M[1,:]
3x4 Array{Float64,2}:
 1.0       1.0       1.0      1.0
 0.516884  0.675712  2.11216  9.0797
 1.00641   0.726229  2.48336  4.38751

julia> M./M[:,1]
3x4 Array{Float64,2}:
 1.0  0.891557  0.561464  0.103968
 1.0  1.16552   2.29433   1.82633
 1.0  0.643353  1.38544   0.453257

대신 다음과 같이해야합니다.

julia> M./M[[1],:]
3x4 Array{Float64,2}:
 1.0       1.0       1.0      1.0
 0.516884  0.675712  2.11216  9.0797
 1.00641   0.726229  2.48336  4.38751

julia> M./M[:,[1]]
3x4 Array{Float64,2}:
 1.0  0.891557  0.561464  0.103968
 1.0  1.16552   2.29433   1.82633
 1.0  0.643353  1.38544   0.453257

이 제안이 현재 우리가 가지고있는 모든 주요 문제를 해결한다고 생각합니다

1. 대칭 슬라이스 동작 – 후행 치수는 더 이상 특별하지 않습니다.
2. v'' === v
3. v' == v
4. v'w 는 v 및 w 의 내적입니다. 특히, 요소가 하나 인 벡터가 아니라 스칼라입니다.
5. v*w' 는 v 및 w 의 외부 곱입니다.
6. M*v 는 벡터입니다.
7. M*v' 은 오류입니다.
8. v'*M 는 전치 벡터입니다.
9. v*M 은 오류입니다.
10. At_mul_B 연산자와 특수 구문 분석이 사라집니다.

: +1 : 모두에게. 나는 # 6837에서 2와 3에 대해 약간의 작업을했지만 끝내지 못했습니다. @simonbyrne 도 조사했습니다.

+1도. 모든 곳에서 매우 일관된 행동을 제공 할 것 같습니다.

이 제안의 유일한 방해 요소는 M[1,:] 가 명시 적으로 수평 행 행렬이 아니라 암시 적으로 수직 벡터라는 점입니다. 그렇지 않으면 실제로는 매우 부드럽고 중단없는 일련의 변경 사항입니다 (하나는 희망). (나에게있어) 주된 깨달음은 APL 슬라이싱 동작이 lazy transposes와 결합 될 수 있다는 것입니다. 우리가 동의하면 계획을 세우고 작업을 분할 할 수 있습니다. 나는 lazy transposes와 staged 함수가 약간의 코드 감소와 단순화를 허용하기를 바랍니다.

예, 부탁합니다! Tensor transpose는 기본적으로 희미한 반전을 사용하여 사용자 정의 순열을 허용해야합니다.

Tensor transpose는 기본적으로 희미한 반전을 사용하여 사용자 정의 순열을 허용해야합니다.

유형을 약간 복잡하게 만드는 것 같습니다. 아마도 임의의 지연 차원 순열을 허용하는 PermuteDims 유형을 가질 수 있습니다.

@Stefan : 이것은 벡터와 2-dim을 계산하는 데 꽤 좋은 생각 인 것 같습니다.
대수학. 몇 가지 문제 :

1. 다차원 배열의 경우 : 차원이있는 배열 A의 경우
   (i_1, i_2, ..., i_n), [i_2, i_3]에 조옮김을 적용하려면
   차원 또는 [i_2, i_4] 차원의 해시. 당신은 그것을 할 수 있습니까
   전치의 새로운 정의?
2. 싱글 톤 차원과 관련하여 : 싱글 톤 슬라이스가 다음과 같을 수 있습니다.
   의도적으로 떠났습니다. Julia가이 싱글 톤 차원을
   계산? 예를 들어 벡터를 배열 V로 정의한 경우
   (2,1)의 차원, 그리고 행렬 A와 전치를 곱하기를 원합니다.
   차원 (2,3,4). 다음의 차원에서 v '* A의 결과를 산출 할 수 있습니까?
   (1,3,4)?

2014 년 10 월 16 일 목요일 오후 2:31, Stefan Karpinski [email protected]
썼다 :

유일한 방해 요소는 M [1 ,:]이 (수직) 벡터라는 것입니다.
행 행렬이 아니라. 그렇지 않으면 실제로 꽤 부드럽습니다.
무중단 변경 세트 (하나는 희망). (나에게) 주된 깨달음은
APL 슬라이싱 동작은 게으른 전치와 결합 될 수 있습니다. 우리가 얻는다면
동의하면 계획을 세우고 작업을 분할 할 수 있습니다. 나는 진정으로 원한다
게으른 전치 및 단계적 함수는 일부 코드 감소 및
단순화.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.
https://github.com/JuliaLang/julia/issues/4774#issuecomment -59425385.

Re 2 & 3 : 거칠게 찔러서 벡터 전치가 AbstractVector 의 하위 유형이되어서는 안된다는 결론에 도달했습니다. 가장 건전한 방법은 Transpose{T,A} <: AbstractMatrix{T} 및 별도의 Covector 유형 (+ Conjugate 변형)을 사용하는 것입니다.

내가 만난 또 다른 중요한 문제는 특정 행렬 유형, 전치 또는 켤레 전치에 대해 디스패치하려는 경우가 많다는 것입니다. 불행히도 기존 유형 기계를 통해이를 표현하는 방법을 찾을 수 없었습니다 ( 이 메일 링리스트 토론 참조). 이것이 없으면 3x3 가능한 인수 조합에 대해 @eval -ing을 많이 할까 봐 걱정됩니다.

@simonbyrne , 구현에 대한 귀하의 경험을 연기합니다. 나머지는 합리적으로 보입니까?

잠재적 인 대안은 SubArrays가 사용할 수있는 인덱스 유형을 확장하여 모든 _internally_ 쉐이핑을 처리하는 것입니다 (공개적이지 않은 포럼에서 여기에 간략하게 언급 됨). 특히, 상위 배열이 Vector 일 때에도 SubArray에 전치 된 모양을 부여하는 "전치 된 범위"유형을 가질 수 있습니다. (서브 어레이가 어떻게 구현되는지 잘 모르는 경우 https://github.com/JuliaLang/julia/blob/d4cab1dd127a6e13deae5652872365653a5f4010/base/subarray.jl#L5-L9 참조)

이 대안 전략이 삶을 더 쉽게 만드는지 더 어렵게 만드는지 확실하지 않습니다. 외부를 향하는 유형의 수를 줄여서 더 적은 수의 메소드가 필요함을 의미 할 수 있습니다. (때문에에 방법이 누락에 _still_ 충전 사람으로 Color 에서 전환 Images ,이 좋은 것처럼 보인다.) 한편,이 수 편리 삼각형 파견의 부재 @simonbyrne이 제기 한 문제를 악화시킬 수있는 선택적 메서드를 작성하는 것이 다소 어색하게 만듭니다.

어떤 통찰력이라도 가장 환영받을 것입니다.

이러한 세부 사항 외에도 @StefanKarpinski 의 제안 형태가 듭니다 . 나는 APL 스타일 인덱싱에 얽매이지 않지만 균형 적으로 현재 우리가 가지고있는 Matlab에서 파생 된 규칙보다 더 나은 선택이라고 생각합니다.

두 가지 생각 :

• A[[2], :] 와 같은 인덱싱이 관용적이되는 경우 단일 인덱스 2 를 래핑하기 위해 벡터를 생성해야하는 것은 약간 낭비 인 것 같습니다. 같은 것에 대해 A[(2,), :] 를 허용하는 것을 고려해야합니까? 단일 요소 범위가 괜찮다고 생각하지만 [2] 만큼이나 편리한 구문을 사용하는 것이 좋습니다.
• 브로드 캐스팅을 위해 일치하는 차원 수를 요구해야한다면 배열에 단일 차원을 추가하는 간단한 방법이 있어야합니다. 아마도 numpy의 newaxis 인덱싱과 같은 것입니다.

나는 세미콜론을 사용한 인덱싱 (la A[2;:] )이 결과가 항상 A 와 동일한 수의 차원을 갖는 다른 인덱싱 모드가 될 수 있다고 제안하고있었습니다. 즉, 싱글 톤을 삭제하지 않고 인덱싱 둘 이상의 순위를 갖는 것은 오류입니다. 단순함을 위해 핵심 제안에서 제외하기로 결정했지만, 그런 것이 있으면 좋은 것 같습니다.

@simonbyrne에 의해 표현 된 우려를 볼 수 있습니다. 그러나 원칙적으로 코 벡터는 다른 벡터 공간, 즉 이중 공간에 사는 벡터 일뿐입니다. 따라서 Transpose 또는 Covector 유형을 AbstractArray 의 하위 유형이 아닌 것으로 만드는 것도 다소 기분이 좋지 않습니다. 주요 주요 변경 사항이며 고려되지 않을 가능성이있는 해결책은 전체 AbstractArray 패밀리에 추가 유형 매개 변수 trans , :N , :T 또는 :C 값을 가질 수 있습니다. 벡터가 숫자의 1 차원 목록이라고 가정하는 모든 메서드의 경우이 최종 매개 변수의 다른 값을 구분할 필요가 없으므로 해당 메서드 정의가 현재 그대로 유지 될 수 있습니다.

N> 2 인 N 차원 배열의 경우 다양한 옵션이 있습니다. transpose 중 하나는 오류를 제공하며 AbstractArray{3,Float64,trans} 유형의 객체를 실제로 생성하는 것은 불가능합니다. 여기서 trans!=:N , 또는 :T 는 행 주를 의미합니다. 일반 배열의 transpose 는 모든 차원을 반대로하는 효과가 있습니다. 나는 후자가 Penrose 그래픽 표기법을 사용하는 사람들이 받아 들인 관례라고 생각합니다.

transpose 에서 지원되는 임의의 인덱스 순열에 대한 역할을 실제로 보지 못합니다. permutedims 이 있으며 개선 된 SubArray를 사용하는 게으른 접근 방식이있을 수 있습니다. 또한이 문제의 주된 동기는 A_mul_B 동물원을 단순화하는 것이며, 고차 텐서 수축은 어쨌든 정상적인 곱셈을 통해 지원되지 않습니다 (그리고 지원되어서는 안됩니다).

이 접근 방식과 관련하여 아직 생각하지 못한 몇 가지 새로운 문제가 있다고 확신합니다.

여기서 디스패치 문제에 대한 합리적인 해결책을 찾았다 고 생각

@Jutho 의 제안은 흥미로워 보이며 탐구 할 가치가 있다고 생각합니다. 불행히도 이러한 것들을 평가하는 유일한 방법은 그것들을 구현하는 것입니다.

@toivoh ,

• A[2:2,:] 도 차원을 유지하며 할당이나 새 구문이 필요하지 않습니다.
• newaxis 와 같은 것은 매우 실현 가능해 보입니다. 실제로 # 8501의 아키텍처를 사용하면 인덱싱을 통해 직접 방송을 생성 할 수있는 것 같습니다. 사용자가 해당 슬롯에 어떤 값을 입력하든 항상 1로 확인되는 인덱스 유형을 갖습니다.

와 문제 2:2 대신의 인덱스에 대한 긴 표현이있는 경우 반복이다 2 . 그러나 물론 인덱스에서 범위를 생성하기 위해 항상 자신의 함수를 정의 할 수 있습니다.

아주 좋은 제안 : +1 :.

v' == v 원하는 이유를 알려주세요.

우리는 그것이 실제로 필요하지 않지만 (유한 차원) 벡터 공간의 이중이 동형이기 때문에 다소 좋습니다.

또는 더 강하게 줄리아의 배열은 공변 인덱스와 반 변성 인덱스를 구분하지 않기 때문에 이것을 데카르트 공간 (Euclidean metric = Identity matrix = kronecker delta)의 벡터라고 생각하는 것이 합리적입니다. 동형.

나는 우리가 v '== v를 원한다고 확신하지 않지만, 그것은 꽤 직교한다고 생각합니다.
나머지. 열 행렬과 벡터가 같은 경우 비교하기를 원합니까?
동일한 요소가 있습니까?

차원 수가 다르기 때문에 실제로는 다른 문제입니다.

특히,이 제안은 벡터와 열 행렬 사이의 식별을 효과적으로 제거합니다. 행렬을 수평 또는 수직으로 슬라이스하면 어느 쪽이든 벡터를 얻을 수 있기 때문입니다. 이전에는 후행 단일 치수를 무시하거나 실제로 존재하는 것보다 더 많은 척할 수있었습니다. 벡터는 배열의 모든 슬라이스에서 나올 수 있기 때문에 더 이상 그렇게하는 것은 좋은 생각이 아닙니다.

후행 단일 차원을 추가하여 1-d에서 2-d로 convert 무언가를하는 것이 합리적일까요?

이 제안으로 더 이상 좋은 생각이 아닐 수 있다고 생각합니다. 그러나 벡터는 여전히 열처럼 동작하고 covector는 행처럼 동작하기 때문일 수 있습니다.

# 8416에서 내가 주목 한 한 가지는 sparsevec 이 현재 단일 열 CSC 매트릭스로 지저분하게 위조된다는 것입니다. Sparse는 적절한 1-d sparse 벡터 유형이 구현되면 여기에 상당히 잘 맞을 수 있어야합니다 (일반 Nd COO 유형의 가장 간단한 유용한 경우로 떨어 지므로 작성해야 함).

이 모든 것을 받아들입니다. 그래서 다음은 작동하지 않을까요?

A [1 ,:] * A * A [:, 1] # 행렬의 행 * 행렬 * 행렬의 열 ???

당신은 썼다

v'w는 v와 w의 내적입니다. 특히, 요소가 하나 인 벡터가 아니라 스칼라입니다.

또한 v '* w는 스칼라입니까?

나는 모양이 (1, ..., 1, m, 1, ..., 1) 인 두 항목을 취하는 dot (x, y) 아이디어를 좋아합니다.
무슨 일이 있어도 내적을 반환합니다. 그러나 나는 x * y가 이런 의미에서 dot (x, y)를주는 것을 원하지 않습니다.
x가 코 벡터이고 y가 벡터가 아니면.

이것이 그렇게 뜨거운 아이디어인지 확실하지 않지만 아마도
A [:, 1,1]은 벡터이고 A [1, :, 1] 또는 A [:, 1, :]는 코 벡터입니다.
벡터의 차원 (슬롯)을 따라 추적하는 것이 좋습니다.
표준 선형 대수를 사용하여 텐서를 축소 할 수 있습니다.
1 (행 벡터) 및 2 개의 열 벡터.

제가보기에이 문제에서 이전에 다루었던 두 가지 주요 과제는 다음과 같습니다.

(A) 다차원 데이터에서 작동 할 때 텐서 의미론 (축약 용)과 배열 의미론 (방송용)을 구별하는 방법;
(B) 더 높은 차원으로 일반화되는 일관된 프레임 워크 내에 명확하고 편리한 선형 대수를 포함하는 방법.

이 제안이 이러한 문제 중 하나를 어떻게 처리하는지 명확하지 않습니다. 내가 말할 수있는 한, (A)를 달성하려면 여전히 임시 사용자 조작이 필요합니다 (현재의 기능과 마찬가지로). 지연 래퍼를 사용하여 (B)를 해결하려면 @timholy가 제안한 SubArray 확장과 같은 것이 필요 하며 ,이 시점에서 얼마 전에 논의 된 마스킹 접근 방식의 지연 버전이됩니다. 비슷한 게으른 메커니즘 (예 : List 래퍼 유형)을 사용하여 (A)에 대한 추가 지원을 제공하는 것을 상상할 수 있지만 이러한 모든 경우에 게으름은 선택적인 전략이어야합니다.

나는 "어쨌든 더 높은 텐서 수축이 정상 곱셈을 통해 지원되지 않는다 (그리고 지원되어서는 안된다)"라는 @Jutho 의 견해를 얼마나 많이 공유하는지 모르겠지만, 더 이상 동의 할 수 없었습니다. 수학, 나는 항상 그것들이 필요합니다. Mathematica 및 NumPy와 같은 현재 언어에는 이와 관련하여 디자인 제한이 있지만 (위에서 논의했듯이) 최소한 지원됩니다! 예를 들어, 간단한 수치 방법으로 벡터 장의 기울기를 사용하려면 고차 텐서 수축이 필요합니다.

"...이 점에서 디자인 제한이 있습니다 (위에서 설명했듯이), 최소한 지원됩니다"라고 말할 때, 누락 된 기능에 대해 말하는 것입니까, 아니면 해결할 수없는 벡터 및 전치에 대한 근본적인 것입니까? 더 높은 수준 또는 기능을 추가하여?

이 제안에 대해 (A) 및 (B) 포인트가 향상되는 것과 _ 충돌 _하는 것이 있습니까?

나는 실제로 matlabs 표준 곱셈 연산자 * 또는 다른 내장 matlab 함수를 통해 텐서 수축이 어떻게 지원되는지 알지 못합니다. Numpy에는 내장 기능이 있지만 (이름을 잊었습니다) 내가 기억하는 한 다소 제한적입니다.

저도 항상 가장 일반적인 형태의 텐서 수축이 필요합니다. 이것이 바로 가장 일반적인 텐서 수축을 지정하는 것이 효율적으로 구현하는 것은 말할 것도없고 완전히 간단하지 않은 이유입니다. 그렇기 때문에 사용 사례의 절반을 다루지 않는 Julia base의 표준 연산자에 반쯤 작동하거나 특정 기능을 밀어 넣으려고하기보다는이를위한 특수 기능이 필요하다고 주장했습니다. 그러나 나는 내 의견을 바꾸게되어 기쁩니다. 예를 들어 다른 어떤 것보다 훨씬 더 중요하고 유용한 '표준'축약이 있다면? 그러나 이것은 매우 도메인에 따라 달라질 수 있으므로 Julia Base에서 채택하기위한 일반적인 규칙으로 적합하지 않습니다.

Op 19-okt.-2014 om 22:52 heeft thomasmcoffee [email protected] het volgende geschreven :

제가보기에이 문제에서 이전에 다루었던 두 가지 주요 과제는 다음과 같습니다.

(A) 다차원 데이터에서 작동 할 때 텐서 의미론 (축약 용)과 배열 의미론 (방송용)을 구별하는 방법;
(B) 더 높은 차원으로 일반화되는 일관된 프레임 워크 내에 명확하고 편리한 선형 대수를 포함하는 방법.

이 제안이 이러한 문제 중 하나를 어떻게 처리하는지 명확하지 않습니다. 내가 말할 수있는 한, (A)를 달성하려면 여전히 임시 사용자 조작이 필요합니다 (현재의 기능과 마찬가지로). 지연 래퍼를 사용하여 (B)를 해결하려면 @timholy가 제안한 SubArray 확장과 같은 것이 필요 하며 ,이 시점에서 얼마 전에 논의 된 마스킹 접근 방식의 지연 버전이됩니다. 비슷한 게으른 메커니즘 (예 : List 래퍼 유형)을 사용하여 (A)에 대한 추가 지원을 제공하는 것을 상상할 수 있지만 이러한 모든 경우에 게으름은 선택적 전략이어야하는 것처럼 보입니다.

나는 "어쨌든 더 높은 텐서 수축이 정상 곱셈을 통해 지원되지 않는다 (그리고 지원되어서는 안된다)"라는 @Jutho 의 견해를 얼마나 많이 공유하는지 모르겠지만, 더 이상 동의 할 수 없었습니다. 수학, 나는 항상 그것들이 필요합니다. Mathematica 및 NumPy와 같은 현재 언어에는 이와 관련하여 디자인 제한이 있지만 (위에서 논의했듯이) 최소한 지원됩니다! 예를 들어, 간단한 수치 방법으로 벡터 장의 기울기를 사용하려면 고차 텐서 수축이 필요합니다.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.

여기 A의 마지막 지수와 B의 첫 번째 지수에 대한 수축이 있습니다.
일종의 mathematica의 점처럼

function contract(A,B)
   s=size(A)
   t=size(B)
   reshape(reshape(A, prod(s[1:end-1]), s[end]) *  reshape(B,t[1],prod(t[2:end])) , [s[1:end-1]... t[2:end]...]...)
end

저는 항상 형태 변경, 순열, 아마도 복잡한 것으로 일반적인 수축을 할 수있었습니다.
위와 같이 다소 필요할 때 접합체

텐서의 큰 문제가 실제로 무엇인지 확실하지 않습니다. 왜이 중 몇 가지만 구현하면 안됩니다.
기능?

네, 맞습니다. 이번 호에서 우리가 앞으로 나아가고 자하는 것은

1. 인덱싱에서 어떤 차원을 삭제해야합니까? "APL 스타일"은 논란의 여지가없는 것 같습니다.
2. vector' 는 무엇을 제공합니까?

텐서 수축의 경우 적절한 유형과 단계적 함수를 사용하면 실제로 고성능 구현을 얻을 수 있다고 생각합니다.

내 느낌은 텐서가 스스로를 돌볼 것이고 우리는
선형 대수 사용자는 좌절하지 않습니다.

내 가장 큰 관심사는

(2d 배열에서 행 가져 오기) * (2d 배열) * (2d 배열에서 열 가져 오기)

일반적인 작업은 우리가 취하지 않으면 여전히 작동하지 않습니다
(행 가져 오기) covector 또는 아마도 더 나은
일반 슬롯 인덱스로 태그를 지정합니다.

@JeffBezanson , 이러한 작업이 지원된다는 것은 내장 데이터 유형 및 함수가 Mathematica의 Dot 함수와 같이 특별히이를 염두에두고 설계되었음을 의미합니다. 따라서 사용자에게는 특정 작업을 수행하는 기본 제공, 문서화 및 / 또는 명백한 방법이 있습니다. 모든 디자인에 대해 현재 구현에서와 마찬가지로 기능을 추가하여 모든 것을 지원할 수 있습니다. 기술적 인 갈등의 문제가 아니라 디자인의 문제입니다.

@Jutho , 저는 MATLAB을 많이 사용하지 않아 댓글을 달 수 없습니다. 나는 NumPy의 디자인이 Mathematica의 디자인보다 덜 일관 적이라는 데 동의하지만 (위에서 논의했듯이) 더 다양한 동작을 지원합니다. 기본 선형 대수가 필요하지 않은 사용자에게는 일반 텐서 기계가 보이지 않게해야한다는 데 동의하지만 Julia의 뛰어난 언어 기능으로 인해 NumPy와 Mathematica가 가지고있는 것처럼 다양한 구현을 도입 할 필요가 없어 보입니다. 어느 정도 강제되었습니다. 나에게이 문제는 적어도 부분적으로는 두 가지 모두에 적합한 통합 시스템을 찾는 것으로 보 였는데, 일반적인 선형 대수 사례에 어떤 전문화를 사용해야하는지 예를 들어 vector' 대해해야 할 일을 밝히는 것입니다.

A [1 ,:] * A * A [:, 1] # 행렬의 행 * 행렬 * 행렬의 열 ???

맞습니다 – A[1,:]' * A * A[:,1] 를 써야합니다.

또한 v '* w는 스칼라입니까?

예, v'w 은 동일합니다. 이 제안을 방해하는 좋은 것 중 하나는 값싼 구문 해킹을 완전히 제거한다는 것입니다.

이것이 그렇게 뜨거운 아이디어인지 확실하지 않습니다 ...

나는 그렇게 생각하지 않는다. 이 제안의 목표 중 하나는 슬라이싱 및 인덱싱 규칙을 대칭으로 만드는 것이며, 이것은 인덱스 중 하나를 특별하게 만들어 전체 목적을 무너 뜨리는 것처럼 보입니다. 슬라이싱이 비대칭 적이라면 현재 동작을 유지하는 것이 좋습니다.

@thomasmcoffee 좀 더 구체적으로 말하면됩니다. 물론 모든 사람들은 일관되고 문서화되고 명백하기를 원합니다. 문제는 테이블에있는 제안이 이러한 목표에 부합 하는가? 아마도 현재의 제안이 이러한 목표에 전혀 영향을 미치지 않을 수도 있습니다. 괜찮습니다. 다른 곳에서 개선으로 이어지는 한, 우리는 여전히 순 개선을 가지고 있습니다.

그러니 이걸 똑바로하겠습니다

A가 정사각형이 아닌 경우

| | 현재 | 제안 | MATLAB |
| --- | --- | --- | --- |
| A * A [1 ,:] | 아니오 | 예 | 아니오 |
| A * A [1 ,:] '| 예 | 아니오 | 예 |
| A [:, 1] A | 아니오 |
A [:, 1] ' A | 예 | 예 | 예 |

A가 정사각형이면

| | 현재 | 제안 | MATLAB |
| --- | --- | --- | --- |
| A * A [:, 1] | 예 | 예 | 예 |
| A * A [:, 1] '| 아니오 | 아니오 | 아니오 |
| A [1 ,:] A | 아니오 |
A [1 ,:] ' A | 아니오 | 예 | 아니오 |

나는 이것에 대한 답변을 방금 게시했지만 어떻게 든 에테르로 사라졌습니다. 이것은 모두 정확합니다. 현재 배열에서는 전치할지 여부를 결정할 때 행 슬라이스 또는 열 슬라이스를 사용하는지 여부와 왼쪽 또는 오른쪽으로 곱할지 여부를 고려해야합니다 (열은 왼쪽으로, 행은 오른쪽으로 바뀜). 제안에서, 당신은 당신이 곱하는 쪽만 고려합니다 – 당신은 항상 왼쪽에서 조옮김하지 않고 오른쪽에 있지 않습니다.

괜찮을까요?

dot(x,y) 및 dot(x.',y) 및 dot(x,y.') 및 dot(x.',y.') 모두 동일한 스칼라를 제공합니까?

즉 Σᵢ conj (xᵢ) * yᵢ

이렇게하면 너무 많이 생각하지 않고 dot (x, A * y)를 할 수 있습니다.

@alanedelman의 이러한 예제는 APL 인덱싱으로 인해 안되는 위치에서 약간 받습니다 . 아마도 그것은 내가 논의했던 것처럼 (예를 들어 A[i; :] ?) 인덱싱의 변형을 보존하는 차원을 가질 수있는 충분한 동기입니다.

그러나 위의 경우에 covector를 제공하기를 원할 것입니다.

@alanedelman , dot 메서드가 존재하지 않아야하고 동일한 결과를 제공해야하는 이유가 없습니다.

저는 항상 형태 변경, 순열, 아마도 복잡한 것으로 일반적인 수축을 할 수있었습니다.
위와 같이 다소 필요할 때 접합체

이것이 바로 TensorOperations.jl의 tensorcontract 함수에서 구현되는 방법입니다. : BLAS 방법을 선택하면 확실히 큰 텐서에 가장 빠릅니다. 또한 순열 (추가 메모리 할당)의 필요성을 제거하고 더 작은 텐서의 경우 더 빠른 Cartesian.jl 기능을 사용하는 네이티브 줄리아 구현을 작성했습니다.

나는 MATLAB이 Julia가 제공하지 않는 내장 기능을 제공한다는 잘못된 주장에 응답했습니다. 모양 변경과 순열 모두 Julia에서 사용할 수 있습니다. Numpy에는 실제로 이것을 정확히 수행하는 tensordot 함수가 있지만 출력 텐서의 인덱스 순서를 지정할 수 없으므로 특정 출력 순서를 염두에두고 있다면 나중에 순열이 필요합니다.

그러나 이것은 실제로 벡터 및 행렬 대수에 대한 일관된 동작을 얻는 현재 주제에서 너무 멀어지고 있습니다.

스테판의 제안에 +1. 매우 명확하지만 충분히 유연한 의미를 제공하는 것 같습니다. 선형 대수 사용자로서, MATLAB 스타일 구문에 익숙한 사람이라도 사용하기에 충분히 간단한 규칙을 찾을 수있었습니다.

' 이 일반적으로 무엇을 의미하는지에 대해 약간 혼란 스럽습니다. v 이 벡터이면 v' 는 transpose 입니다. a 가 2D 배열 인 경우 a' 는 이제 transpose 됩니다. 둘 다 b 의 첫 번째 차원을 a 의 첫 번째 차원과 축소하여 b' * a 를 쉽게 형성 할 수 있도록 정의 된 것 같습니다.

a 의 차원이> 2 a' 의 정의에 대한 합의가없는 것 같습니다. 나는 누군가가 치수를 반전 이외의 제안 듣고이 일치하지 않은 b' * a 의 첫 번째 차원 계약 b 의 첫 번째 차원과 a .

' 이 작동하는 것의 크기를 언급하지 않고 간결하게 설명 할 수 있다면 좋을 것 같습니다.

예를 들어, 일반적인 상황에 대한 자료에서 사용할 수있는 다른 수축 기능을 가지고 합리적인 것 같다 contract(a, b, 2, 3) 의 2 차원 계약 a 의 3에 b .

그건 그렇고, dot(a,b) == a'*b a 및 b 이 벡터이지만 dot(a,b) 는 현재 행렬에 대해 정의되지 않은 경우 dot(a,b) = trace(a'*b) 을 (를) 가질 수 있습니까?

@madeleineudell : '이 일반적으로 의미하는 바에 대해 약간 혼란스러워합니다.

저는이 우려를 공유합니다. 기본적으로 내 제안에서 속성 2-5, 7, 8 및 10을 정의 특성으로 사용할 수 있습니다. 즉, 이것을 유지하기를 원합니다.

• v' 은 1 차원이지만 벡터는 아닙니다.
• v'' === v
• v' == v
• v'w 은 스칼라입니다.
• v*w' 는 행렬입니다.
• v'*M 는 v' 와 같은 종류입니다.
• M' 는 2 차원이지만 행렬이 아닙니다. 행렬보기 일 수 있습니다.

특히, 더 높은 차원의 배열에 대해 의미하거나 수행하는 것에 대한 제약이 없습니다. 코 벡터가 무엇인지에 대한 일반적인 이론은 더 높은 차원을 포함하는 것이 좋지만, 예를 들어 위 / 아래 차원을 갖거나 각 차원을 인덱스로 레이블링하는 것과 같이 일을 너무 복잡하게하지 않고 실제로 수행 될 수 있다고 확신하지 않습니다.

적어도 ' 대한 일반적인 규칙은 벡터와 코 벡터에 대해 수행 할 작업이 아니기 때문에 차원을 반전시키는 것이 아니라는 것이 분명합니다.

내가 생각할 수있는 유일한 간단한 규칙은 벡터, 코 벡터 및 행렬 모두에 대해 위의 동작을 캡처하는 것입니다 (벡터에는 두 번째 차원이없고 코 벡터에는 첫 번째와 현재 두 번째가 없음).

2014 년 10 월 20 일 09:05에 toivoh [email protected] 은 다음과 같이 썼습니다.

적어도 '에 대한 일반적인 규칙은 벡터와 코 벡터에 대해 수행 할 작업이 아니기 때문에 차원을 반전시키는 것이 아니라는 것이 분명합니다.

내가 생각할 수있는 유일한 간단한 규칙은 벡터, 코 벡터 및 행렬 모두에 대해 위의 동작을 캡처하는 것입니다 (벡터에는 두 번째 차원이없고 코 벡터에는 첫 번째와 현재 두 번째가 없음).

일반 텐서에 대해 생각하고 싶다면 이것은 사실이 아니라고 주장합니다. 행렬과 벡터를 숫자가있는 일부 블록으로 만 생각하고 v를 열로, v '를 행으로 생각하면 사실 일 수 있습니다.

그러나 v를 벡터 공간의 일부 요소로 생각하고 w = v '를 이중 공간 V_의 요소 w에 v를 매핑하는 방법으로 생각하면 w는 여전히 벡터, 즉 1 차원 객체입니다. 일반적으로 V에서 V_로이 매핑을 정의하려면 메트릭이 필요합니다. 즉, w_i = g_ {i, j} v ^ j입니다. 이제 V가 데카르트 공간, 즉 표준 유클리드 메트릭을 사용하는 R ^ n이면 V *는 자연적으로 V와 동형이됩니다. 이것은 상위 또는 하위 인덱스 (공변 또는 반반 변) 개념이 없으므로 w_i = v_i입니다. = v ^ i = w ^ i. 나는 이것이 대부분의 프로그래밍에서 사용되는 경우, 즉 Julia Base가 지원해야하는 경우라고 주장합니다. (복소 벡터 공간의 경우 V *는 자연적으로 Vbar, 켤레 벡터 공간과 동형이므로 자연 매핑은 w_i = conj (v ^ i)입니다.)

벡터를 숫자가있는 열로, 이중 벡터를 숫자가있는 행으로, 따라서 행렬 (V \ ox V_의 요소)을 숫자가있는 블록으로 표시하는 규칙은 매우 편리하지만 더 높은 차원을 고려하려는 경우에는 중단됩니다. 배열, 즉 고차 텐서 제품 공간의 요소. 이 경우 '행 벡터', 즉 첫 번째 차원의 크기가 1 인 2 차원 객체, 즉 matlab / julia 용어로 말하자면 텐서 곱 공간 V1 \ ox V2의 일부 요소입니다. 여기서 V1은 R (또는 다른 1 차원 공간)입니다. 나는 이것이 기본 동작으로 원하는 것이 아닐 수도 있다는 데 동의하지만, 일반 배열에 대해 전치를 정의하고 matlab과 같이 순열을 참조하지 않는 것이 좋습니다. 일반 텐서의 처음 두 차원을 기본 규칙으로 바꾸는 것은 의미가 없습니다. 일부 고차 텐서 제품 공간 V1 \ otimes V2 \ otimes… \ otimes Vn에 고유 한 정의가 없습니다. 모든 차원을 뒤집는 규칙은 위에서 언급 한 Penrose의 편리한 그래픽 표현에서 비롯됩니다. 또한 이것은 행렬 공간 (V \ otimes V_)을 자신 (V * \ otimes V * = V \ otimes V )에 매핑하는 것입니다.

앞으로 두 가지 방법을 볼 수 있습니다.
1) 데카르트 텐서 설정 내에서 선택한 규칙을 사용하여 편의 연산자 '(그리고 어쩌면 *)가 임의의 고차 배열과 함께 작동하도록합니다 (즉, 상위 인덱스와 하위 인덱스를 구분하지 않음). 이것은 일반적인 사용 사례에 대해 놀라운 결과를 가져올 수 있습니다.

2) '와 *를 벡터와 행렬로 제한합니다. 고차 배열에 오류가 있습니다. 이것이 가장 인기있는 접근 방식이라고 생각합니다 (예 : Matlab 등).

이 게시물은 작년에 내가 취한 입장에서 다른 쪽을 취한 것입니다.

양쪽에서 양면성을 탐구하십시오.

괜찮 길 바랍니다.
드디어 현재의 접근 방식에 논리가 있다는 사실을 알게되었지만 명확하게 표현되지 않았습니다.
해킹처럼 보였기 때문에 짜증이났습니다. 왠지 이해 했으니
나는 그것을 더 좋아한다.

현재 접근 방식에서 모든 배열은 1이 내포되어 무한 차원입니다.
아포스트로피 연산자 '는 처음 두 차원을 교환하는 것을 의미 할 수 있습니다.
하지만 사실 오늘날 존재하기 때문에

ndim (A) <= 2? interchange_first_two_dims : no_op

다른 사람들이 그걸보고 내가 놓친다면 미안 해요. 내 마음은 수렁에 빠졌다
벡터는 무한한 차원이 아니라 1 차원이라는 생각으로
따라서 조옮김은 차원을 반대로해야하므로 no_op이됩니다.

나는 아포스트로피가이 작업을 수행하거나 아포스트로피가 항상 바뀌어도 괜찮습니다.
처음 두 가지 차원은 상관 없다고 생각합니다. 아포스트로피가 존재한다고 생각합니다
다 선형 대수가 아닌 선형 대수를 위해.

나는 아포스트로피 별표 ( " '*") (가능하다면! 또는 불가능하다면 다른 것)를 가지고 놀았다.
마지막 차원을 첫 번째 차원으로 축소하는 것을 의미해야합니다 (예 : Mathematica의 점)
인덱싱이 많고 코 벡터가 없습니다. 내 뇌의 일부는 여전히 탐구 할 가치가 있다고 생각합니다.
그러나 내가 깨어 나면 현재의 접근 방식이 더 좋아지고 더 좋아 보입니다.
(오늘 나중에 내 기분을 보자)

작년에이 스레드를 시작한 후 후회하지 않지만 어떤 경우인지 다시 궁금합니다.
오늘날 사람들을 정말 짜증나게합니다 ... 예제 목록을 얻을 수 있습니까? ... 그리고 여부
이러한 경우에 빛을 비추는 것이 우리가하는 일을 바꾸는 것보다 낫습니다.

이 글 전체를 읽었고 많은 원칙을 봤습니다.
하지만 내 머리를 둘러싼 사용 사례가 충분하지 않습니다.

나는 자주 짜증이 났다고 말할 수 있습니다.

[1 2 3] # ndims == 2
[1,2,3] # ndims == 1
[1; 2; 3] # ndims == 1

주로 기억이 안 나기 때문입니다.

그냥 생각 실험입니다. @alanedelman 이 '* 대해 염두에 둔 것과 유사한 축소 연산자로 사용하도록 * 를 재정의하면 어떤 기능이 손실됩니까? 선형 대수 연산에서 ' 에 대한 필요성을 전혀 제거하지 않겠습니까 (행렬에 대한 전치 기능 제외)? 나는 그것이 outer(w,v) 로 쉽게 대체 될 수있는 외부 제품 w*v' 배제 할 뿐이라는 것을 알 수 있습니다.

편집 : APL 슬라이싱을 가정합니다. 예를 들어 A[1,:]*A*A[:,1] 는 첫 번째 피연산자를 ' 로 전치 할 필요없이 예상 결과를 얻을 수 있습니다.

나도 생각 했어. v * w가 내적이라는 것은 마치 스테로이드에 과부하가 걸리는 것처럼 보입니다.
오류가 발생하기 쉽습니다.
이것은 mathematica의 점이 그렇게 나쁘지 않은 곳입니다.

요약하자면 마지막에서 처음까지의 계약은 합리적으로 보이지만
아포스트로피 별표 또는 * 또는 점이어야하는지 여부
문제가 있습니다.

약간 무관하지만 완전히 무관하지는 않습니다 ....
모든 사람들이 원래 닷 스타로 ​​읽었던 닷 스타 (내가 말했듯이)는
POINTWISE 연산자는
의미했다

나는 자주 짜증이 났다고 말할 수 있습니다.

[1 2 3] # ndims == 2
[1,2,3] # ndims == 1
[1; 2; 3] # ndims == 1

주로 기억이 안 나기 때문입니다.

저는 항상 " , 만 사용하지 않는 이유는 무엇입니까?"

@alanedelman 이 '*에 대해 염두에 둔 것과 유사한 축소 연산자로 사용하도록 *를 재정의하면 어떤 기능이 손실 될 수 있습니까?

우리는 연관성을 잃을 것입니다. 예를 들어 (M*v)*v 는 현재 dot(v,M*v) (스칼라)를 제공하는 반면 M*(v*v) 는 M.*dot(v,v) (행렬)을 제공합니다.

왜 우리는 dot 를 축소 연산자로 만들지 않습니까 (어쨌든 연관성이 아님)? 우리는 또한 ddot(A::Matrix,B::Matrix) == A⋅⋅B == trace(A'*B) 와 같은 고차 수축을 정의 할 수 있습니다.

그래서 벡터 전치를 도입하는 유일한 목적은 * 의 비 연관성으로부터 우리를 구하는 것임을 올바르게 이해하고 있습니까? @alanedelman 예제의 모호성은 벡터 중 하나 ( M*v*v' 대 M*v'*v )를 전치하여 수정할 수 있지만 괄호 ( M*(v*v) 대 (M*v)*v )를 사용하여 동일하게 수행 할 수 있습니다 @Jutho가 이미 고차 텐서에 대한 전치 구현을 지적했듯이 수학적으로 의미가 없습니다). 나에게 질문은 어떤 표기법이 더 읽기 쉽고 간결하며 우아하고 순수하다는 것입니다.

실제로 M*(v*v) 및 (M*v)*v 는 현재 모두 다음과 같이 구문 분석됩니다.

*(M, v, v)

인수의 크기에 따라 곱셈 순서를 최적화하는 행렬 곱을 허용하려면 파서도 변경해야합니다.

하지만 적어도 개인적으로 저는 연관성이 꽤 큰 문제라고 생각합니다. 수학과 대부분의 프로그래밍 언어를 번역해야합니다. 줄리아에게는 여전히 번역을 많이하지 않으 셨으면합니다.

( @Jutho가 이미 고차 텐서에 대한 전치 구현을 지적했듯이 어쨌든 수학적으로 의미가 없습니다).

나는 그것이 정확히 내가 말한 것이라고 생각하지 않습니다.

@alanedelman 이 '*에 대해 염두에 둔 것과 유사한 축소 연산자로 사용하도록 *를 재정의하면 어떤 기능이 손실 될 수 있습니까?

우리는 연관성을 잃을 것입니다. 예를 들어 (M_v) _v는 현재의 dot (v, M_v) (스칼라)를 제공하는 반면 M_ (v_v)는 M._dot (v, v) (행렬)을 제공합니다.

왜 점을 축소 연산자로 만들지 않습니까 (어쨌든 연관성이 아님)? 고차 수축을 정의 할 수도 있습니다. 예를 들어 ddot (A :: Matrix, B :: Matrix) == A⋅⋅B == trace (A '* B).

이러한 추론을 통해 벡터와 행렬에 대한 곱셈 연산자가 더 이상 필요하지 않습니다. 모든 것을 점으로 쓸 수 있습니다.
A ∙ B
A ∙ v
v ∙ A ∙ w
v ∙ w

그래서 그것은 @pwl 제안이지만 *는 점으로 대체되었습니다.

하지만 적어도 개인적으로 저는 연관성이 꽤 큰 문제라고 생각합니다. 수학과 대부분의 프로그래밍 언어를 번역해야합니다. 줄리아에게는 여전히 번역을 많이하지 않으 셨으면합니다.

문제의 일부는 수학에서도 다른 관습이 있다는 것입니다. 행 및 열 벡터 수학 측면에서 생각하고 있습니까, 아니면 선형 연산자 및 이중 공간 측면에서 더 추상적 인 동작을 원합니까 (연산자는 벡터와 곱하지 않고 벡터에 적용됩니다. A * v 또는 A ∙ v 대신 A (v)?

저는 편의 구문이 크게 필요하지 않습니다. 저는 개인적으로 v '* w보다 dot (v, w)를 매번 쓰는 것을 선호합니다. 전자가 기초 독립적 인 수학적 연산을 더 명확하게 표현하기 때문입니다 (사실, 먼저 a를 정의해야합니다. 벡터에서 이중 벡터로의 자연 매핑 이전의 스칼라 곱도 정의 할 수 있습니다.)

그렇게 무지해서 미안하지만, M[1, :] 이 정확히 v' 처럼 행동 할 수없는 이유는 무엇입니까?

나는 나를 괴롭히는 것들의 목록에 추가 할 것입니다.

1.

[1 2 3] # ndims == 2
[1,2,3] # ndims == 1
[1;2;3] # ndims == 1

2.
v=rand(3)
v' * v curently has ndims == 1 ( @StefanKarpinski 의 제안이이를 수정 함)
(v' * v)/( v' * v ) 에는 ndims ==2 (이것은 정말 저를 괴롭 히고 수정 될 것입니다)

여전히 나는 covectors를 정말로 원하지 않습니다.
그리고 apl 인덱싱은 내가 앞뒤로 계속하는 것입니다.
--- 여전히 생각하고 있지만 그 목록을보고 싶습니다.
현재 줄리아의 다른 사람들에게 버그

나는 확실히 cdot의 아이디어를 좋아합니다* 연산자 외에 마지막 인덱스를 첫 번째 인덱스로 축소
그리고 dot (a, b, ..)를 허용하면 매우 일반적인 경합이 가능합니다.

Numpy의 명명 규칙에도 불구하고 (그리고 아마도 이전 게시물의 모습), 일반적인 텐서 수축에 점을 사용하는 것에 대해 다소 혼합 된 느낌이 있습니다. 이것은 Wikipedia의 첫 번째 문장입니다.

수학에서 내적 또는 스칼라 곱 (또는 유클리드 공간의 맥락에서 때때로 내적)은 두 개의 동일한 길이의 숫자 시퀀스 (일반적으로 좌표 벡터)를 취하고 단일 숫자를 반환하는 대수 연산입니다.

내 생각에도 도트는 스칼라를 반환해야합니다.

@ brk00 , 귀하의 질문에 대한 문제는 이것을 더 높은 차원 / 더 높은 순위의 조각으로 확장하는 방법이 명확하지 않다는 것입니다 (나는 이것을 위해 세계 차원을 정말 싫어합니다) 배열.

그렇게 무지해서 미안하지만 M [1, :]이 v '처럼 행동하는 전치가 될 수없는 이유는 무엇입니까?

할 수 있지만 어떻게 일반화합니까?

@Jutho , 미안합니다. 다르게 표현 했어야 했어요. "고차 텐서 제품 공간에서 요소를 전치하는 것은 [...] 고유 한 정의가 없습니다."라는 줄을 의미 했으므로 하나의 특정 정의를 도입하거나 정의 할 수있는 수학적 동기가 없습니다.

@alanedelman :

나는 나를 괴롭히는 것들의 목록에 추가 할 것입니다.

[1 2 3] # ndims == 2
[1,2,3] # ndims == 1
[1; 2; 3] # ndims == 1

연결 동작은이 문제와 관련이 없습니다. 더 이상 물을 진흙으로 만들지 말자.

* 연산자 외에 마지막 인덱스를 첫 번째 인덱스로 축소하는 cdot의 아이디어가 마음에 듭니다.
그리고 dot (a, b, ..)를 허용하면 매우 일반적인 경합이 가능합니다.

이것은 또한 접선입니다. 배열과 슬라이싱에 계속 집중합시다.

현재 접근 방식에서 모든 배열은 1이 내포되어 무한 차원입니다.

이것은 사실이 아닙니다. 이것이 사실이라면 ones(n) , ones(n,1) , ones(n,1,1) 등은 구별되지 않을 것입니다. 다른. 우리는 그것들이 _ 비슷하게 _ 동작하도록 구현하기 위해 약간의 노력을 기울이지 만, 그것은 배열이 실제로 무한 차원 인 것과는 거리가 멀다.

현재 귀찮은 것들의 목록은 위의 제안의 좋은 속성을 크게 반영합니다. 즉:

1. 비대칭 슬라이스 동작 – 후행 치수는 특별합니다.
2. v'' !== v – 실제로 v'' != v ; 같은 계급이 없기 때문입니다.
3. v' != v – 동일한 거래.
4. v'w 는 스칼라가 아니라 요소를 1 개 가진 벡터입니다.
5. A*_mul_B* 대한 특별한 파싱이 필요합니다. 이것은 가장 끔찍한 일입니다.

나는 v' == v 비트를 제외하고 @StefanKarpinski 의 포인트 대부분에 동의합니다. 예, 그것들은 동형 일 수 있지만, 그들은 매우 다르게 동작한다는 점에서 여전히 다른 객체입니다. 행렬 M 및 M' 도 동형이지만 동일하기를 원하지는 않습니다. (물론 Hermitian이 아니라면).

Covector 유형에 대한 일반적인 견해는 기본 연산 (곱하기, 덧셈 등)을 제외하고는 상대적으로 가벼워 야한다는 것입니다. 우리는 너무 많은 연산을 정의하는 것을 피할 것입니다 (인덱싱을 정의하는 것을 주저 할 것입니다. ). 그것으로 무언가를하고 싶다면, 그것을 벡터로 다시 변환하고 거기에서 작업을해야합니다.

+1의 견해 '@StefanKarpinski 자신의 일반적 승인을 포함하여,의 테이크'를 @simonbyrne합니다.

@simonbyrne도 동의합니다.

예, v 및 v' 에는 다른 유형이 있지만 이미 동일한 모양과 데이터를 가진 서로 다른 배열 유형이 동일한 것으로 간주합니다 (예 speye(5) == eye(5) . 코 벡터가 희소와 다른 이유는 무엇입니까?

코 벡터가 행 행렬처럼 브로드 캐스트되기를 바랍니다. 동일한 것으로 간주되는 A 및 B 배열의 경우 지금까지

all(A .== B)

하나가 벡터이고 하나가 코 벡터 인 경우에는 그렇지 않습니다.

나에게 covector는 벡터 또는 열 행렬보다 행 행렬과 더 비슷합니다.

핵심 질문은 size(v' )입니까? 답이 (length(v),) 이면 v == v' 가 사실이어야한다고 생각합니다. size(v') == (1,length(v)) 이면 아마도 거짓이어야하지만 틀림없이 v' == reshape(v,1,length(v)) 는 참이어야합니다. 그래서 질문은 v' 이 특별한 종류의 벡터가되어야 하는가 아니면 특별한 종류의 행렬이되어야 하는가하는 것입니다.

점점 더이 문제가 전치가 실제로 의미하는 바에 관한 것이라고 확신합니다.

코 벡터는 실제로 배열이 아니므로 그들이 가진 "모양"이 무엇인지 실제로 말할 수 없다고 생각합니다. 코 벡터는 실제로하는 일에 의해 정의됩니다. 즉, *(::Covector, ::Vector) 는 스칼라를 제공합니다. AbstractVector 는 그렇게하지 않으므로 실제로는 동일하지 않습니다.

또 다른 문제는 복잡한 필드에 있습니다. v' == v 또는 v.' == v ?

@simonbyrne :

코 벡터는 실제로하는 일에 의해 정의됩니다. 즉, *(::Covector, ::Vector) 는 스칼라를 제공합니다. AbstractVector 는 그렇게하지 않으므로 실제로는 동일하지 않습니다.

이것은 정말 좋은 점입니다. 그러나 v' 를 객체로 사용할 수없는 경우 다소 답답할 수 있습니다. 아마도 올바른 접근 방식은 v' 를 재미있는 벡터 대신 재미있는 행 행렬로 취급하는 것입니다.

아마도 올바른 접근 방식은 v '를 재미있는 벡터 대신 재미있는 행 행렬로 취급하는 것입니다.

종류이지만 AbstractMatrix 의 하위 유형이되어야한다고 생각하지 않습니다. AbstractCovector 이 최상위 유형이어야한다고 생각합니다. length(::Covector) 를 정의하고 싶지만 size 메서드를 정의해야한다고 생각하지 않습니다.

방송 처리에 대해 잘 모르겠습니다. 합리적인 기준을 마련 할 수 없다면 방송 방법을 정의하지 않는 편이 낫습니다.

이 논의는 공학에서 사용되는 것과 같은 전치와 벡터를 사용하는 것으로 수렴하는 것 같습니다. 즉, 모든 것이 행렬이라고 생각합니다. 벡터를 열로, 대류 벡터를 행으로 생각하십시오. 이것은 데카르트 공간 (일반적인 사용 사례)의 벡터 및 선형 맵에 적합하지만, 다중 선형 대수 또는보다 일반적인 벡터 공간 등으로 일반화하려고하면 실패하기 시작합니다. 다음과 같은 사실에서 비롯되는 많은 혼란이있는 것 같습니다. 데카르트 공간 많은 것들이 일반 공간과 동등하지 않은 동등합니다. 나는 이것이 줄리아의 기본 행동으로 반드시 반대하는 것은 아니지만, 위의 진술 중 일부는 마치 "수학적으로 옳은"것처럼 동의하지 않습니다. 그래서 아래의 내용과 모순됩니다.

2014 년 10 월 20 일 17:39에 Simon Byrne [email protected] 은 다음과 같이 썼습니다.

나는 v '== v 비트를 제외하고 대부분의 @StefanKarpinski 의 포인트에 동의합니다. 나는 이것들이 동일해야한다고 생각하지 않습니다. 예, 그것들은 동형 일 수 있지만 그들은 매우 다르게 행동한다는 점에서 여전히 다른 객체입니다. 행렬 M과 M '도 동형이지만 우리는 그것들이 동일하기를 원치 않을 것이라고 생각합니다 (물론 Hermitian이 아니라면).

이 진술은 어떤 수준에서도 의미가 없습니다.

1), 나는 당신이 여기서 동형의 의미를 남용하고 있다고 생각합니다. Isomorphic은 두 공간 간의 관계입니다 (이 설정에서). 일반적으로 모든 (실제) 벡터 공간 V에는 선형 함수의 이중 공간 V *가 있습니다 (복소 공간의 경우 켤레 공간과 켤레 공간의 이중 공간도 있습니다). 이들은 일반적으로 다른 공간이며, 하나에서 다른 것으로의 고유하거나 자연스러운 매핑조차 없습니다. 즉, 일반적으로 V의 요소 v를 V *의 요소 phi에 연관시키는 의미가 없습니다. 유일한 일반적인 연산은 선형 함수를 적용하는 것입니다. 즉, phi (v)는 스칼라입니다.

V x V-> 스칼라 (일반적으로 내부 곱 / 메트릭)의 쌍 선형 형식이 있으면 V에서 V * 로의 자연스러운 매핑을 정의 할 수 있습니다. 그런 다음 phi_i = g_ {i, j} v ^ j를 정의 할 수 있습니다.

2) 실제로 "벡터 전치"와 관련된 자연스러운 연산이 없습니다 (포인트 3 참조). 이러한 혼란은 열 행렬로 벡터를 식별 할 때 발생합니다.
너무 강하다고 생각하면 실제로 도트 및 외부 곱 / 텐서 곱 연산을 사용하여 얻을 수없는 벡터 전치의 사용 사례를보고 싶습니다.

그러나 벡터를 이중 벡터에 매핑하는 방법으로 전치를 사용하려는 경우, 즉 V의 v를 V_의 일부 phi = v '에 매핑하려면 표준 유클리드 내적 (g_ {)을 사용한다고 가정합니다. i, j} = delta_ {i, j}). 그 시점에서 당신은 공변 성과 반 변성 인덱스의 구분을 없애고 본질적으로 데카르트 텐서로 작업하고 있으며 V와 V_는 자연적으로 동형이됩니다. 위에서 언급했듯이, w_i = v ^ i = v_i = w ^ i, 그래서 예, v == w 그리고 나는이 둘을 구별하는 것이 없다고 말할 것입니다.

3) "전치"작업은 원래 V-> W (http://en.wikipedia.org/wiki/Dual_space#Transpose_of_a_linear_map)의 선형 맵에 대해서만 정의되었으며 실제로 거기에서도 생각하는 바를 의미하지 않을 수 있습니다. 선형 맵 A : V-> W의 전치는 W _-> V_의 맵 A ^ T입니다. 즉, W_의 벡터, 이중 벡터에서 작동하고 V_의 요소, 즉 V의 코 벡터를 생성합니다. 즉, 행렬 A의 일반적인 전치 A ^ T로 생각한다면,이 행렬 A ^ T는 W *의 벡터를 나타내는 열과 곱해 져야하며 이로부터 나오는 열은 V의 공동 벡터를 나타냅니다. 따라서이 시점에서 행 벡터가있는 이중 벡터 식별은 이미 실패합니다.

그러나 V * 및 W *가 표준 유클리드 내적을 통해 V 및 W로 식별되는 실제 벡터 공간의 일반적인 사용 사례에서는 선형 맵의 전치가 해당 선형 맵의 인접 요소로 식별 될 수 있습니다. 대부분의 사람들이 생각하는 V-> W의 맵이 맵의 전치의 경우이기도합니다. 복잡한 경우, 이것은 일반적인 행렬 전치 (복합 결합없이)는 맵 W _-> V_로만 의미가 있기 때문에 실패합니다. 맵 W-> V로서 이것은 기본 독립적 정의가 아니므로 작동 상 의미가 없습니다.

고차원 배열에서 전치가 의미하는 바에 관해서는 우리가 수렴하는 MATLAB / 엔지니어링 접근 방식 내에서 : 오류 여야하며 일반화되지 않습니다. 이것은 그것을 정의 할 방법이 없다는 것을 의미하지 않습니다. 문제는 고차 배열이 무엇을 나타내는가하는 것입니다. 텐서 곱 공간 V1 \ otimes V2 \ otimes… \ otimes VN, V1 x V2 x… x VN에 작용하는 다중 선형 맵인가, 일부 텐서 곱 공간 V1 \ otimes V2 \ otimes의 선형 맵입니까? … \ otimes VN을 다른 텐서 제품 공간 W1 \ otimes W2 \ otimes… \ otimes WM? 2 차원의 경우에는 해결 방법이 있습니다. 선형 맵 식별 A : V-> W와 W의 벡터 \ otimes V_, 선형 맵 감각의 전치는이 텐서 곱 공간의 공간 반전에 해당합니다. A ^ i_j-> A_j ^ i와 V_ \ otimes의 A ^ T W = V * \ otimes W _, 실제로 W

결론적으로 문제는 줄리아의 벡터가 수학적 의미에서 임의의 일반 벡터의 속성을 캡처해야하는지 아니면 숫자 열, 목록,… 단어 벡터, 텐서,… -수학에서 정의 된 연산 및 기초 독립적 인 의미로, Julia Vector에서 정의하려는 연산의 종류와 충돌 할 수 있습니다. 반대로, 표준 Julia (Abstract) Vector 유형은 서로 다른 벡터 공간을 구분할 방법이 없기 때문에 일부 객체는 실제로는 수학적 관점 (이중 벡터 등)의 벡터이며 Julia Vectors로 식별해서는 안됩니다.

그 점에서 매트릭스라는 용어가 훨씬 덜 과부하되기 때문에 약간의 비대칭이 있습니다. 심지어 수학적 관점 에서조차 매트릭스는 특정 기준에서 선형지도의 편리한 표현 일뿐입니다. 선형 맵을 행렬로 나타내지 않고 함수로 표현하고 싶지 않은 경우도 많이 있습니다 (이 문제는 이전에 eigs의 인수 등에서 발생했습니다). 그런 점에서 왜 matlab이 진정한 1 차원 구조 인 벡터를 가지지 않았는지 알 수 있습니다. 이 접근 방식에서는 모든 것이 '행렬', 즉 숫자가있는 블록으로 해석됩니다.

질문? c를 코 벡터라고합시다. fft (c)는 무엇입니까?

답 : 예상치 못한 방식으로 복잡한 켤레를 취하는 fft (c ')'
fft (c)와 비교할 때

사용자는 정의되지 않은 이점을 누릴 수 있습니다.
(또는 잘 문서화되어 있다면 이것은 사용자에게 좋을 것입니다 ??)

이런 종류의 것들이 훨씬 더 많을 것 같아요

지금 Base 에서 옳은 일은 다음과 같이 정의하는 것입니다.

• covector 곱하기 다른 벡터
• 코 벡터 곱하기 행렬
• covector '를 사용하여 벡터를 얻습니다.

현재 코 벡터에 대한 최소한의 지원에 +1합니다.

네, +1.

그래서 내가 언급했다면
norm (covector, q)는 norm (vector, p)이어야합니다. 여기서 1 / p + 1 / q = 1
홀더 불평등으로 인해 오랫동안 구현되지 않았습니다. :-)

p = q = 2에 대한 감사합니다

구현하기가 그렇게 어렵지 않을 것입니다.

norm(c::Covector, q::Integer) = norm(c.vector, q/(1-q))

q == 0 및 q == 1 를 피하기 위해 추가 검사를 원할 것입니다.

q == 1이면 괜찮을 것 같아요

Med Venlig Hilsen

안드레아스 노악

2014-10-22 15:19 GMT-04 : 00 Stefan Karpinski [email protected] :

구현하기가 그렇게 어렵지 않을 것입니다.

norm (c :: Covector, q :: Integer) = norm (c.vector, q / (1-q))

q == 0 및 q == 1을 피하기 위해 추가 검사를 원할 것입니다.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.
https://github.com/JuliaLang/julia/issues/4774#issuecomment -60139762.

나는 covector 제안 (내가 주로 지원하는)에 대한 글을 작성하고 있지만, @StefanKarpinski 의 "재미있는 행 행렬"개념을 정확하게 만드는 한 지점을 지금 게시하는 것이 유용 할 수 있습니다.

코 벡터는 벡터가 아니지만 그 이유에 대한 설명이 항상 명확하지는 않습니다. 코 벡터 (또는 물리학 자들이 부르는 브래지어-벡터)는 벡터를 먹고 내적인 숫자를 뱉어내는 선형 함수입니다.

더 정확하게:

• V = V(F) 및 W = W(F) 요소의 일부 필드 F 에 대한 벡터가되도록합니다.
• v 및 w 는 각각 V 및 W 요소 인 벡터입니다.
• <.,.> 는 <.,.> : V × W → F 및 v, w ↦ <v, w> 와 같은 내부 제품이어야합니다.

v 에 해당하는 코 벡터는 w ↦ <v, w> 매핑을 수행하는 선형 함수 v' : W → F 입니다.

일반적인 설명은 v' 이 이중 공간 V* 의 요소이며 이중 공간 _is_에 대해 많이 언급하지 않는 것으로 끝납니다.

컴퓨터 과학 사용자의 경우 첫 번째 매개 변수와 관련하여 내부 제품의 커링으로 v' , 단일 매개 변수 인 함수 모음으로 V* 라는 간단한 설명이 있습니다. 첫 번째 벡터가 다른 카레.

이 Wikipedia 기사 는 두 설명과 관련된 다른 표기법을 조정하는 데 도움이 될 수 있지만 정확히 동일한 개념을 표현하고 있습니다.

또한 처음에는 covector 로의 인덱싱이 허용되지 않아야한다고 생각했습니다. 그러나 v'[1] 인덱싱은 v' 을 표준 기저 벡터 e₁ = (1, 0, ...) 에 적용하는 것과 동일하므로 v'[1] 를 <v, e₁> 로 정의 할 수 있습니다. 1:n 와 같은보다 일반적인 인덱싱 의미 체계는 v' 를 적절한 프로젝션 행렬에 적용하고 각 열이 표준 기저 벡터 인 경우 자연스럽게 따릅니다.

# 987의 맥락에서 코 벡터의 인덱싱 의미를 고려하면 코 벡터가 AbstractVector 가 아닌 또 다른 이유가 있습니다. 일반적으로 v' 인덱싱 <v, e₁> 처럼 계산합니다. 일반적으로 <v, w> = v'*A*w 행렬에 대해 정의 된 내부 곱을 가질 수 있으며 인덱싱 비용은 matvec 제품 A*w (또는 A'*v )에 의해 결정됩니다. AbstractVector 자격을 얻기에는 너무 비쌉니다.

우리가 DFT와 규범에 대해 이야기하고 있기 때문에 ... 이것이 오늘 제 마음을 사로 잡았습니다.

경우 f 벡터의 함수 인 스칼라를 생성하고 I는 싶은 diff(f) 허용 함수로 Vector 하고 생성 Covector 그래서 f(x) ~= f(x0) + diff(f)(x0) * (x-x0) . 기울기의 매우 일반적인 사용은 입력의 증분 변화가 주어지면 함수 출력의 증분 변화에 대한 선형 근사치를 얻는 것입니다. 입력이 벡터이면 그라디언트가 입력의 모든 차원을 따라 축소되는 것이 자연스럽게 느껴집니다.

하지만 그래디언트 디센트를 구현하려면 x 에 그래디언트를 추가해야합니다 (확장 된 버전). 이러한 의미에서 그래디언트는 가장 가파른 방향을 가리키는 벡터이며, 그 규범은 가장 가파른 방향을 따라 변화하는 속도에 비례합니다.

내 직감은 "한 점에서의 벡터 입력 함수의 기울기는 코 벡터"가 더 중요하다고 말합니다.

현재 Base에서해야 할 옳은 일은 다음과 같이 정의하는 것입니다.

covector 곱하기 다른 벡터
코 벡터 곱하기 행렬
covector '를 사용하여 벡터를 얻습니다.

내 이전 무서운 게시물에서 얻은 인상에도 불구하고 이것에 +1하십시오.

그럼에도 불구하고 이에 대한 몇 가지 언급 :

나는 covector 제안 (내가 주로 지원하는)에 대한 글을 작성하고 있지만, @StefanKarpinski 의 "재미있는 행 행렬"개념을 정확하게 만드는 한 지점을 지금 게시하는 것이 유용 할 수 있습니다.

코 벡터는 벡터가 아니지만 그 이유에 대한 설명이 항상 명확하지는 않습니다. 코 벡터 (또는 물리학 자들이 부르는 브래지어-벡터)는 벡터를 먹고 내적인 숫자를 뱉어내는 선형 함수입니다.

이중 벡터 / 코 벡터 (선형 함수라는 용어도 선호 함)는 내적없이 정의 할 수 있다고 생각합니다. V에서 V 로의 매핑을 정의하려면 내부 곱이 필요합니다 *

더 정확하게:

V = V (F) 및 W = W (F)를 요소 F의 일부 필드에 대한 벡터라고 가정합니다.
v와 w는 각각 V와 W의 요소 인 벡터이고,
<.,.>는 <.,.> : V × W → F 및 v, w ↦이되는 내적이어야합니다.
두 개의 서로 다른 벡터 공간 V와 W 사이에 내적을 정의하는 것은 매우 이상하고 불가능하다고 생각합니다. 양의 정의 속성을 어떻게 정의합니까?
v에 해당하는 코 벡터는 선형 함수 v '입니다. w ↦ 매핑을 수행하는 W → F.

일반적인 설명은 v '가 이중 공간 V *의 요소라는 말로 끝납니다. 이중 공간이 무엇인지에 대해 다른 말은 많지 않습니다.

유한 차원의 경우 이중 공간은 이름 그대로 벡터 공간이라는 것이 분명합니다. 그러나 이전의 호언을 요약하면 Julia의 (Abstract) Vector 유형이 목록과 더 비슷하다는 것입니다. 특정 벡터 및 벡터의 수학적 구조가없는 기타 1 차원 데이터 구조를 나타내는 데 사용할 수 있지만 수학적 벡터 인 모든 개체를 캡처하는 것은 충분히 일반적이지 않습니다 (다른 벡터를 구별 할 수 없기 때문입니다). 공백).

# 987의 맥락에서 코 벡터의 인덱싱 의미를 고려하면 코 벡터가 AbstractVectors가 아닌 또 다른 이유가 있습니다. 일반적으로 v '를 저렴하게 인덱싱하는 것은 불가능합니다.= v'_A_w이고 인덱싱 비용은 matvec 제품 A_w (또는 A'_v)에 의해 지배되며, 이는 AbstractVector로 인정하기에는 확실히 너무 비쌉니다.

이것은 일종의 루프 인수입니다. 위에서 언급했듯이 선형 함수 (코 벡터)는 더 일반적이며 내적이없는 벡터 공간에서도 존재합니다. 둘째, 메트릭이 양의 정부 호 행렬 A 인 경우 벡터 v에서 코 벡터로의 자연스러운 매핑은 실제로 v'_A입니다. 그러나 여기서이 v '는 무엇입니까? 이미 v에서 표준 유클리드 노름과 관련하여 정의 된 다른 코 벡터로의 매핑입니까 (메트릭과 같은 ID 포함)? 전혀 그렇지 않다. 벡터에 반 변성 (상위) 인덱스가 있고 공 변성 (하위) 인덱스가있는 경우 메트릭 A에는 2 개의 하위 인덱스가 있고 내적은 다음과 같습니다.= v ^ i A_ {i, j} v ^ j. 따라서이 매핑은 phi_j = v ^ i A_ {i, j}와 같이 (벡터 v에 연결된 코 벡터 인 phi를 사용하여) 작성 될 수 있습니다. (이는 w ^ i = O ^ i_j v ^ j 형식의 일반적인 선형 연산자와 다릅니다.) 따라서이 표현식 v'_A에서 v는 여전히 상위 인덱스를 가진 v이고 여전히 동일한 벡터입니다.

그래서 실제로 제가 위에서 말하고자했던 점 중 하나는 사람들이 코 벡터로 작업하려고하지 않을 때 종종 v '를 쓴다는 것입니다. 내적과 같이 벡터에 정의 된 표현식을 작성하려고합니다.또는 v'_A_w로 친숙한 행렬 표현 내에서 v ^ i A_ {i, j} w ^ j와 같은 것입니다. 표준 유클리드 내적 v'w조차도 v ^ i delta_ {i, j} w ^ j로 읽어야하며 대류 벡터를 도입 할 필요가 없습니다. 위에서 언급했듯이, 나는 대부분의 응용 프로그램에서 숨겨진 형태의 스칼라 제품이 아닌 실제 적절한 코 벡터의 사용이 다소 제한적이라고 생각합니다. 사람들은 편리한 행렬 구문을 사용할 수 있도록 v '를 작성하지만 실제로하는 일은 코 벡터가 아닌 벡터와 관련하여 정의 된 내적 등을 계산하는 것입니다.

제쳐두고, 스테판의 원래 제안에서와 같이 v '== v를 가질 수 있다면 곱셈의 연관성에 대한 몇 가지 언급이있었습니다. 그러나 이것이 없어도 v '가 일반 벡터로 식별되지 않는 코 벡터 인 경우에도 *가 연관 적이라고 말하지 않습니다.
A_ (v'_w)는 행렬입니다.
(A_v ') _ w에서 오류가 발생합니다.

스칼라 값 함수의 기울기는 실제로 covectors의 적절한 응용 중 하나입니다. 즉, 인수가 없으면 기울기는 covector입니다. 켤레 기울기와 같은 응용 프로그램에서 암시 적으로 가정되는 것은 이러한 코 벡터를 다시 벡터로 매핑하는 메트릭 (실제로 역 메트릭)이 있다는 것입니다. 그렇지 않으면 x ^ i (위치 벡터) + 알파 g_i (그래디언트)와 같은 작업을 수행 할 필요가 없습니다. 이를 작성하는 적절한 방법은 x ^ i + alpha delta ^ {i, j} g_j입니다. 여기서 delta ^ {i, j}는 역 메트릭입니다. 사소하지 않은 메트릭을 사용하여 매니 폴드에서 최적화 기술을 정의하려는 경우이 메트릭을 고려해야합니다. 이것에 대한 좋은 책이 있습니다.
http://sites.uclouvain.be/absil/amsbook/
및 해당 MATLAB 패키지 :
http://www.manopt.org

2014 년 10 월 22 일 22:52에 goretkin [email protected]이 다음과 같이 썼습니다.

우리가 DFT와 규범에 대해 이야기하고 있기 때문에 ... 이것이 오늘 제 마음을 사로 잡았습니다.

fis가 벡터의 함수이고 스칼라를 생성하는 경우 diff (f)는 Vector를 받아들이고 Covector를 생성하여 f (x) ~ = f (x0) + diff (f) ( x0) * (x-x0). 기울기의 매우 일반적인 사용은 입력의 증분 변화가 주어지면 함수 출력의 증분 변화에 대한 선형 근사치를 얻는 것입니다. 입력이 벡터이면 그래디언트가 covector가되는 것이 자연스럽게 느껴집니다.

하지만 그래디언트 디센트를 구현하려면 x에 그래디언트를 추가해야합니다 (확장 된 버전). 이러한 의미에서 그래디언트는 가장 가파른 방향을 가리키는 벡터이며, 그 규범은 가장 가파른 방향을 따라 변화하는 속도에 비례합니다.

내 직감은 그래디언트가 covector가 더 중요하다고 말합니다.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.

A_ (v'_w)는 행렬입니다.
(A_v ') _ w에서 오류가 발생합니다.

젠장.

이 스레드는 유머러스 한 이미지가있는 게시물에 대해 기한이 지났습니다.

@Jutho 나는 내가 가장 일반적인 형태의 이중 공간을 사용하지 않는다는 것을 인정하지만, Banach 공간의 틀을 사용하여 이중 공간을 정의하는 선택을 감안할 때 내 설명이 어떻게 원형인지 전혀 알지 못합니다. Banach 공간 형식주의는 어쨌든 유한 차원 벡터 공간에 대해 이미 과잉입니다.

원형은 실제로 올바른 용어가 아닙니다. 이 단락에서 제가 말하고자하는 것은 항목의 효율적인 평가에 관한이 추론을 뒤집을 수 있다는 것입니다. 예를 들어 곡선 매니 폴드의 (공액) 그래디언트의 경우 그래디언트 (코 벡터) g_i 는 효율적으로 계산할 수 있지만 x ^ i (역 메트릭 인 A ^ {i, j} 사용)에 추가 될 해당 벡터 A ^ {i, j} g_ {j}는 효율적이지 않을 수 있습니다. 방금 Github에 내 이전 메시지가 얼마나 잘못 설명되어 있는지 확인했습니다. 이메일을 썼을 때는 괜찮 았습니다. 나는 지금 그것을 고치려고 노력했다. 계속 반복하고 싶지 않으며, 현재 제안에 동의하지 않는 것처럼 (잘못된) 인상을주고 싶지도 않습니다. 내가 만들려고했던 유일한 요점.

1. 이중 공간은 확실히 벡터 공간이므로 그 요소는 벡터입니다. 그러나 목표는 벡터의 수학적 의미를 가진 모든 객체가 Julia의 AbstractVector 의 하위 유형이되거나 AbstractVector 하위 유형 인 모든 객체가 적절한 수학적 특성을 갖는 것은 아닙니다. 벡터 그런 의미에서 Matrix 라는 이름이 Vector 라는 이름보다 훨씬 더 좋아합니다. 따라서이 제안의 일부로 Covector 유형이 도입되는 것이 무엇이든간에 AbstractVector 또는 AbstractArray 의 하위 유형이되어서는 안된다는 사실에 동의 할 수 있습니다. , V *가 자연적으로 V (애플리케이션의 절반을 구성하는 데카르트 공간)와 동형 인 경우에도 마찬가지입니다.
2. 내부 곱을 사용하면 V에서 V_ 로의 매핑을 구성 할 수 있지만 V_의 존재를위한 전제 조건은 아닙니다. 확실히, 이것은 프로그래밍에서 항상 유한 차원의 벡터 공간을 가지고 있고 항상 내부 제품이 있기 때문에 관련없는 문제처럼 들리지만 (응용 프로그램과 관련이 없을 수도 있지만), 제가 시도한 실용적인 요점은 make는 이것입니다. 이 @goretkin으로 좋은 구배의 예처럼, 프로그래밍에 covectors의 적절한 응용 프로그램이 있지만, 대부분의 응용 프로그램에 사람들이 쓰는 경우 v' , 그들은 정말 covector를 구성하려고하지 않는, 그들은 단지 선형을 작성하려고하는 v'_A_w = v ^ i A_ {i, j} w ^ j 또는 v'w = v ^ i delta_ {i, j} w ^ j에서와 같이 두 벡터 간의 매핑 (즉, V x V에서 스칼라로) 편리한 행렬 표현. 나는 dot(v,A*w) 명시 적으로 쓰는 것을 선호하지만 그것은 개인적인 선택입니다. 행렬의 상위 또는 하위 인덱스에 대한 정보가 없기 때문에 v'*A*w 와 같은 스칼라 표현식에서 v' 및 w 모두 벡터 또는 코 벡터 일 수있는 사용 사례를 구성 할 수 있습니다. 수학적 의미에서. 이것의 유일한 결과는 v' Covector 유형을 호출하는 것이 정말 만족스럽지 않은지 확실하지 않다는 것입니다. 이름 Vector 처럼 너무 많은 수학이 있습니다. 대부분의 응용 프로그램에서 정당화되지 않을 수있는 함축적 의미는 다음과 같이 더 많은 (대부분 무관 한) 토론으로 이어집니다.

@jutho +1 (그레디언트가 코 벡터 인 경우)
나는 스티브 스미스의 박사 논문에서 이것을 처음 배웠고이 아이디어를 사용했습니다.
고유 값 계산을위한 켤레 기울기의 모호한 아이디어를 명확하게 설명하기 위해
사람들이 화학과 물리학에서 이야기했던 것입니다.

내부적으로 일관된 방식에 대해 점점 깜짝 놀랐습니다.
자체 포함은 상위 1 개와 하위 색인 1 개를 가진 랭크 2 텐서의 세계입니다.
이것은 우리가 일반적으로 행렬 계산 또는 평범한 선형 대수라고 부르는 것입니다.
도대체 norm (v, p) 또는 fft (v)와 같은 많은 예제를 찾을 수 있지만
벡터인지 코 벡터인지는 다르지만, 좋은 예가 하나도 없습니다 (아직!)
벡터와 하나의 열 행렬에서 자연스럽게 다른 함수의.
(누군가 도와주세요, 분명히 하나, 심지어 많을 것입니다 !!)

저는 또한 몇 년 동안 추상적 인 벡터를 @jutho 처럼
공백은 아직 줄리아로가는 길을 찾지 못했습니다. @StefanKarpinski와 대화를 나눈 것을 기억합니다.
몇 년 전 제 화이트 보드에서 이것에 대해. 여전히 중요한 관심사
1) Julia를 처음 접하는 사람들은 쉬운 경험이 있어야하고
2) 성능
이 멋진 물건을 능가해야합니다.

@jiahao 와 대화 한 결과 두 가지 매우 특별한 세계가 있다는 사실을 알게되었습니다.
선형 대수 (하나의 콘트라와 하나의 co가있는 배열) 및 단순 텐서가 있습니다.
(모든 사람은 공동, 콘트라가 아닙니다). 후자는 APL 및 Mathematica에서 잘 작동합니다.
전자는 선형 대수 전체에 걸쳐 있으며 이전에 MATLAB에서 가장 잘 캡처되었습니다.
그들은 2보다 높은 차원의 배열에 접목되었습니다.
@JeffBezanson 과의 한마디가 그렇게 미친 것

그건 그렇고 나는 그것이 더 이상은 아니지만 약 1 년이 걸린 것 같지만 마침내 이것을 심각하게 받아들이고 있습니다 :-)

에 관해서
A_ (v'_w)는 행렬입니다.
(A_v ') _ w에서 오류가 발생합니다.

행렬 곱하기 "*"만 연관됩니다. 오버로드 된 스칼라 시간 행렬은
연관. 수학이나 MATLAB에서도 마찬가지입니다.

A_ (v'_w)는 행렬입니다.
(A_v ') _ w에서 오류가 발생합니다.

잘 잡았습니다. 비 오류가 다른 답변을 생성하는 경우가 있습니까? 관련 질문 : 스칼라 * 코 벡터는 무엇을해야합니까?

오버로드 된 스칼라 시간 행렬은 결코 연관성이 없습니다. 수학이나 MATLAB에서도 마찬가지입니다.

행렬과 스칼라 만 포함하는 연산 은 연관됩니다 (포인트 3 참조). 벡터를 1 열 배열로 취급 할 수 있으므로 포함해도 문제가 발생하지 않습니다. 여기서 주름은 Covector가 차원을 줄일 수있는 연산자 (벡터를 스칼라에 매핑)이므로 이것이 어떻게 맞는지 잘 모르겠습니다.

스칼라 매트릭스 추가는 더 큰 관심사입니다. 그게 분배 성을 망칠 수 있기 때문입니다.

(A+s)*v != A*v + s*v

이것은 매우 멋진 요약입니다.

@jiahao 와 대화 한 결과 두 가지 매우 특별한 세계가 있다는 사실을 알게되었습니다.
선형 대수 (하나의 콘트라와 하나의 co가있는 배열) 및 단순 텐서가 있습니다.
(모든 사람은 공동, 콘트라가 아닙니다).

이 논의는보다 일반적인 경우를 지원하는 것이 아니라 완전한 일반성을 필요로하지 않는 사람들에게는 너무 혼란스럽고 현재의 AbstractArray 계층 구조에 포함될 수 없으며 패키지에 더 적합하다는 것이 분명합니다. 의 위에). 그러나 논의는 실제로이 두 가지 특별한 세계 중 어느 것이 상호 호환되지 않기 때문에 우리가 지원하고 싶은지입니다.

전자에서 모든 벡터 v 는 열이고, 모든 v' 는 코 벡터이며 모든 행렬은 선형 연산자 V-> W입니다 (예 : W ⊗ V_에 있음). V x V-> 스칼라 (예 : v ^ i A_ {i, j} w ^ j)를 매핑하려면 두 개의 하위 인덱스가있는 행렬 (예 : V_ ⊗ W_에 거주)이 필요합니다. 물론 실제로 사용하고 v'_A*w 로 쓸 수는 있지만 선택한 객체 명명법과 충돌합니다. 또한 더 높은 순서의 배열이 존재하는 공간을 지정하지 않습니다.

후자의 경우 (V == V *)가 있기 때문에 해당 문제를 해결하지만 v' == v 와 같은 놀라운 결과를 얻습니다. 또한이 솔루션은 실제로 실제 벡터 공간으로 제한됩니다. 왜냐하면 표준 유클리드 내적 (예 : '복잡한 데카르트 공간')이있는 복잡한 공간에서도 이중 공간은 자연적으로 V와 동형이 아니라 conj (V) (V bar), 켤레 벡터 공간 (http://en.wikipedia.org/wiki/Complex_conjugate_vector_space의 Hilbert 공간 참조)

그 점의 현재 동작에 비 연관성에 대해서는 v'*v 스칼라하지만 배열을 생성하지 않고, 실제로는 더 일관성이다 그로부터 모두 A*(v'*v) 및 (A*v')*v 오류가 발생합니다.

사물의 "선형 대수"측면은 벡터와 코 벡터를 표현하는 방법에 대한 다양한 선택으로 추가로 해석 될 수 있습니다.

• Covector, 일명 "funny row vector"제안은 우리가 최근에 논의했습니다.
• Matlab 등에 의해 보증되는 (N- 벡터를 Nx1- 행렬로), (N- 행-벡터를 1xN- 행렬로) 병합하는 "진짜 벡터 없음"의미 체계.
• 현재 줄리아 방식-조밀 한 N- 벡터와 Nx1- 행렬을 병합하지 않고 희소 N- 벡터와 Nx1 행렬을 병합하고 N- 행 벡터를 1xN- 행렬로 나타냅니다.

"진짜 벡터가없는"세계에서 병합 (스칼라, 1- 벡터, 1x1- 행렬)이 꼭 필요한지 궁금합니다. @alanedelman 과 나는 어제 이것을 논의했고 수치 선형 대수학에서 벡터 * 스칼라와 스칼라 * 벡터의 commutativity는 모든 곳에서 사용되지만 벡터 * 스칼라 곱은 (N,) * ( ,) 또는 (N, 1) * (1,1).

1) 하루가 끝날 때 가장 중요한 것은 A) 사용 편의성과 B) 성능입니다.
2) 두 세계는 완전한 조화로 공존 할 수 있어야합니다. 엔지니어링 작업을 할 때 텐서 표기법보다 더 직관적이고 쉬운 것은 없다고 생각합니다. 내가 할 수 있다면 한 가지 제안은 환경 플래그를 활성화하거나 프로그램 시작시 패키지를 가져올 수 있습니다. 이것은 사용의 용이성과 간단한 프로그래밍 논리를 허용합니다. 이것이 가능하지 않습니까, 아니면 하나의 중요한 스키마를 선택해야합니까?

두 가지 옵션이있는 것 같습니다
1) 도구 상자, 패치 또는 환경 플래그를 동시에 가져올 수 있도록합니다.
2) 특별한 세계를 통합 할 수 있지만 사용하기 쉽고 빠른 언어 구축

이것이 얼마나 유망한지는 모르겠지만 잠재적으로 흥미로운 연구 분야를 우연히 발견했습니다.

다음 사항에주의를 기울이십시오.

기하 대수 연구 그룹
http://www.mrao.cam.ac.uk/~clifford/pages/introduction.htm

기하 대수 강좌
http://www.mrao.cam.ac.uk/~clifford/ptIIIcourse/course99/

기하 대수의 물리적 응용
http://www.mrao.cam.ac.uk/~clifford/ptIIIcourse/

21 세기 물리학과 공학을위한 통합 수학 언어
http://www.mrao.cam.ac.uk/%7Eclifford/publications/ps/dll_millen.pdf

기하 대수
http://arxiv.org/pdf/1205.5935v1.pdf

기하 대수 컴퓨팅의 기초
http://link.springer.com/book/10.1007%2F978-3-642-31794-1

기하 대수 컴퓨팅
http://link.springer.com/book/10.1007%2F978-1-84996-108-0

이것을 조금 더 살펴보면 정말 놀랍습니다.

대수와 기하학이 분리되어있는 한, 그들의 진행은 느리고 사용이 제한되었습니다. 그러나이 두 과학이 통합되었을 때 그들은 서로의 힘을 빌려주고 완벽을 향해 함께 행진했습니다.

• 조셉 루이스 라그랑주

안경이 필요하고 안경이 필요하다는 것을 모른다고 상상해보십시오. 그리고 안경을 받으면 세상이 갑자기 바뀝니다. GA는 뇌 내부를위한 안경과 같습니다.

• 파블로 콜라 핀토

이 녀석은 옳은 아이디어를 가지고있는 것 같습니다 ... https://github.com/wolftype/versor

일반적인 행렬 연산 라이브러리에는 벡터 및 행렬 곱셈을위한 템플릿 인라인 함수가 있습니다. 기하 대수는 다른 많은 수학 (행렬, 텐서, 벡터 및 거짓말 대수)을 결합합니다. Versor는 유사하지만 다양한 크기의 벡터 및 희소 행렬을 모두 다중 벡터라고하며 xyz 방향 및 변환 행렬을 넘어서는 기하학적 요소를 나타내는 스테로이드에서 사용됩니다. 원, 선, 구, 평면, 점은 이러한 변수를 회전, 비틀고, 확장하고 구부리는 연산자와 마찬가지로 모두 대수적 요소입니다. 이 요소와 연산자는 모두 여러 가지 다양한 방식으로 함께 증식하는 다중 벡터입니다.

이 비디오는 프로그래밍 된 GA 수학 언어 인 Versor에 대해 자세히 설명합니다.
https://www.youtube.com/watch?v=W4p-e-g37tg

이것에 대한 슬라이드입니다. https://github.com/boostcon/cppnow_presentations_2014/blob/master/files/generic_spaces.pdf

컴파일 할 때 속도에 최적화 된 놀라운 텐서 계산을 정말 쉽게 수행 할 수 있습니다.

@ esd100 ,이 스레드에 대한 토론을 제목의 특정 문제에 집중하는 것이 도움이 될 것이라고 생각합니다.

@johnmyleswhite "텐서"라는 용어를 검색했는데 171 번 언급되었습니다 (현재 172 번). 귀하의 진술에 동의하지만 일반적으로이 스레드에는 157 개의 댓글 (현재 158 개)이 있으며, 그중 일부는 원본 게시물의 제목을 직간접 적으로 처리합니다 (Taking vector는 심각하게 전치). 내 게시물은 기하학적 대수를 통해 텐서 수학의 새로운 응용으로 할 수있는 일에 대해 더 높은 관점을 제공함으로써 원본 게시물의 제목을 간접적으로 다루고 있다고 생각합니다. 제 생각에는 Versor가 Julia에 가지고있는 고차원적인 힘을 구축하는 것이 Julia의 추가 된 유익한 기능이 될 것이라고 생각합니다. YouTube 비디오의 제목은 "일반 공간의 일반 프로그래밍 : C ++ 11을 사용한 컴파일 시간 기하 대수"였습니다. C ++ 대신 Julia가 될 수없는 이유를 모르겠습니다. 다시 말하지만 저는 수학 자나 컴퓨터 과학자가 아닙니다.

@ esd100 기하 대수는 흥미롭지 만 이번 호에서 다루는 가장 일반적인 것은 아닙니다. 우리가 주로 관심을 가질 기하학적 대수는 실제 Clifford 대수 Cl (R ^ n, I); 그러나 우리는 또한 복잡한 벡터 Cl (C ^ n, I)에 대한 Clifford 대수 또는 임의의 필드 또는 비 교환 고리 Cl (F ^ n, I)에 대한 대수와 같이 기하학적 대수가 _ 아닌 _ 다른 Clifford 대수에도 관심이있을 것입니다. . 더욱이 우리는 우리 자신을 클리포드 대수로 제한하고 싶지는 않지만 선형 대수가 2 차 형태 (내적 곱)가 반드시 정의되지 않는보다 일반적인 텐서 대수 설정으로 일반화되는 방법을 고려하고 싶습니다.

텐서 대수 설정에서 OP의 " v' is a no-op"제안 은 반전 반 자동화에 일관되게 일반화되기 때문에 완벽하게 의미가 있습니다. 그러나 이것은 테이블에있는 적어도 세 가지 제안 중 하나 일뿐입니다. "v '가 코 벡터를 생성하는"제안이 매우 자연스러운 텐서 합체로 이어지는 쌍대 수 확장 을 고려할 수도 있습니다. "진짜 벡터 없음"제안이 어떻게 텐서 대수로 일반화되는지 잘 모르겠습니다.

@jiahao 매우 유익한 답변에 감사드립니다. 주제를 어느 정도 숙달 한 사람이 빛을 비추는 것이 좋습니다. 더 나은 이해를 위해 이러한 주제를 더 많이 살펴보고 싶습니다. BLAS에 대해 매우 최적화 된 코드가 존재하는 이유가 궁금하지만 Clifford Algebra와 같은 더 복잡한 대수에는 매우 최적화 된 코드가 없습니다.

이 토론이 아직 진행 중인지 확실하지 않지만 이러한 문제가 Julia를 사용하는 데있어 가장 중요하고 성가신 부분이기 때문에 제 의견을 공유하고 싶었습니다. 위 내용 중 일부는 동의하고 일부는 동의하지 않습니다.

기본적으로 우리는 이것을 깨달아야한다고 생각합니다. 모든 Julia 사용자는 이미 Julia에서 구현 된 것처럼 빠른 다차원 배열 (데이터 저장 용)을 원할 것입니다. 많은 / 대부분의 사용자도 선형 대수에 관심이있을 것이며, 앞서 언급 한 배열은 벡터와 행렬에 포함 된 데이터를 패키징하는 편리한 방법입니다. 몇몇 사용자는 일반 텐서 (다 선형) 대수를 원할 것입니다.

문제는 이러한 "베어"배열을 선형 대수의 수학적 개념으로 확장하는 방법입니다. 구문을 일반 수학처럼 보이게 만드는 방법은 무엇입니까? 사람들은 v ''! = v를 편안하게 할 것인가? 기타 등등

첫 번째는 배열을 더 나쁘게 만들고 싶지 않고 선형 대수를 할 수 있다는 것입니다. Vector에 추가 데이터를 추가하거나 Array에 불필요한 템플릿 인수를 추가하고 싶지 않습니다. 우리는 선형 대수를하지 않을 때 C / C ++만큼 빠르기를 원합니다 (그리고 우리가 할 때 C / fortran만큼 빠르기를 바랍니다).

우리 모두가 깨달아야 할 두 번째 사실은 완전한 다차원 텐서 수축에는 상당한 양의 추가 정보가 필요하다는 것입니다. 최대 2 차원 텐서의 경우 A_B'_C * D와 같은 곱셈을 작성하는 반면 일반 텐서의 경우 수축을 정의하는 그래프를 생각하는 것이 더 자연 스럽습니다 (텐서 네트워크 다이어그램 또는 인자 그래프-같은 일이 진행됩니다) 다양한 이름으로). 고차원 텐서의 경우 베어 배열을 감싸고 모든 것을 추적하기 위해 벡터 공간 등으로 장식하는 것이 좋습니다. 이것은 Jutho (및 아마도 다른 사람들)가 작업중인 패키지와 같은 패키지에서 수행 할 수 있습니다. 3 차원 이상의 텐서에서 '의 의미를 고려할 때 의미가 없습니다. 순열이 존재하거나 전용 텐서 패키지를 사용하는 경우 아무도 해당 함수를 사용하는 데 관심이 없을 것입니다.

핵심 사용자는 행렬을 곱하고 벡터를 추가해야합니다. 그들은 행렬을 전치하려고 할 것입니다. 그들은 또한 내부 제품과 외부 제품을 원할 것입니다. 좋든 싫든 이들은 이중 공간과 함께 정의됩니다. 우리는 이것이 실수와 복소수에 대해 무엇인지 알고 있으며 미리 정의되어 있습니다. 그리고 네, 실제 유한 벡터 공간의 이중 공간이 기본적으로 똑같은 느낌이 드는 것은 사실입니다. 그리고 이것이 전체 문제를 흐리게하는 것이라고 믿습니다. 현재 가장 큰 문제는 적절한 이중 벡터가 없다는 것입니다. 그것 없이는 우리가 펜과 종이에서하는 것처럼 줄리아에서 방정식을 "쓸"수 없습니다-큰 문제입니다! 더 중요한 것은 v ''= v가 없다는 것입니다. 이것은 매우 직관적이지 않습니다.

사람들은 내부 또는 외부 제품을 수행하기 위해 이중 벡터를 원하거나 만들 필요가 있습니다. 다음에 *를 만날 때 수행 할 작업을 컴파일러에게 알려주는 간단한 장식 래퍼는 현명한 해결책이며 런타임 오버 헤드가 없어야합니다. 이 이중 벡터 / 코 벡터는 인덱싱 가능하고, 더하기 / 빼기 가능하고, 스칼라로 곱하고, 벡터로 곱하고 (스칼라 반환) 행렬로 곱해야합니다 (코 벡터 반환)-그게 다야! 속도 / 메모리 향상을 위해 내적, 외적, 인덱싱 등에 내장 될 수있는 복잡한 벡터에 대한 복잡한 활용도 명시 적으로 수행하지 않습니다.

나는 우리가 타입 시스템에 복잡성을 추가하고 있다고 걱정하지 않습니다. 사용자가 고등학교와 대학에서 수학을 배웠을 때 수학을 캡슐화하는 데 이것이 필요하다고 생각합니다. 여기서 선형 대수의 Dirac 표기법을 사용하고 있습니다) 등.

BTW이 물건이 Julia 0.4에서 구현 되었다면, 나는 잘 모르겠습니다! 나는 여전히 0.3.4를 이해하기 위해 노력하고 있습니다.

@andyferris , 나는 일반적 제안 은 약간 수정 될 수 있고 잘 작동한다고 생각합니다. M*v' 오류 대신 코 벡터를 생성하고 v*M 오류 대신 벡터를 생성하도록합니다. 나에게 이것은 개념적으로 M 가 치수가 위아래인지에 대해 불가지론 적입니다. 내부 제품에 대해 v'*M*w 또는 v*M*w' 를 쓸 수 있으며 둘 중 하나가 작동합니다.

돌아 다니는 한 가지 생각은 row-major 및 col-major 배열을 사용하고 M.' 를 하나에서 다른 것으로 변경하고 유사하게 v' 를 v 의 row-major 변형으로 사용하는 것입니다.

@andyferris 에게 +1. 또한 벡터, 행렬 및 그 전치의 곱을 작성하기 위해 간결한 행렬 대수 구문을 사용할 수있는 간단한 래퍼 유형 Transpose 및 ConjTranspose 를 원한다고 생각합니다. @StefanKarpinski 제안 의 포인트 2와 관련하여 이러한 래퍼를 AbstractArray 개체의 컨테이너로 제한하지 않고 유형을 AbstractArray 유형 계층 자체의 일부로 만들지 않습니다. Transpose(x) 는 표현식에 x' 를 작성하여 생성 된 유형이어야하며 Transpose 에 디스패치하여 나머지 표현식에 따라 평가를 연기하거나 지연 평가를 가질 수 있습니다. * 사례의 99.9 %에서). 그러나 사람들은 행렬 분해 객체 또는 선형 연산자와 같은 정의를위한 다른 유형과 같이 AbstractArray 계층 구조의 일부가 아닐 수도있는 새로운 유형에 대해이 구문에 의미를 부여 할 수 있어야합니다.

행렬과 벡터의 특정 사례의 경우 M*v' 의 사용 사례를 실제로 볼 수는 없지만 본질적으로 반대하지는 않습니다. 중요한 것은 기본 기대치를 충족한다는 것입니다 (예 : Stefan의 제안 끝의 규칙 2,4,5,6 및 8).

마지막 논의의 주요 요점은 아마도 슬라이싱과의 상호 작용 일 것입니다. 행렬의 행 조각이 자동으로 Transpose 이어야합니까? 여기 내 투표는 APL 슬라이싱 규칙에 대한 것입니다.

@Jutho , 동기는 * 연관성 – A*(v'w) 및 (A*v')*w 둘 다 작동하고 기본 요소 유형의 모듈로 비 연관성 (예 : 부동 포인트).

(A*v')*w 에서 A*(v'*w) 와 동일한 결과를 제공하려면 A*v' 가 N=3 배열이어야합니다. 그게 당신이 염두에 두었던 것입니까? 나는 이것을 완전히 놓쳤다.

좋아요, 매우 흥미 롭습니다. 몇 가지 의견이 있습니다.

먼저 핵심 사용자를 처리해야합니다. 기본적으로 Array{T,n} 를 n 차원 저장소로 사용하는 것이 주요 기능입니다. 그것은 선형 대수학에 대해 아무 생각이 없지만, 줄리아에서 데이터를 조작하고 싶은 프로그래머로 이해한다. 이 때문에 어떤 상황에서도 배열 슬라이스가 공동 벡터를 반환 할 수 없습니다! 이것은 벡터 공간과 그 이중 (예 : 숫자 데이터 또는 "필드")을 정의 할 수있는 특정 데이터 유형 T 에만 적용되는 엄격한 선형 대수 개념입니다.

APL 슬라이싱으로 어느 쪽이든 갈 수 있습니다. 충분히 직관적 인 것 같습니다. 유형이 안정적이며 놀라운 일은 없습니다. 선형 대수를 자체적으로 일관성있게 만들기 위해이 변경을 수행 할 필요는 없다고 생각하지만 ... 좋을 수도 있습니다 (브레이킹 변경 일 수 있음). M[1,:] 가 1xn 크기이고 M[:,1] 가 n (nx1이 아님) 크기라는 것이 불안합니다 ... 너무 비대칭 인 것 같지만 ... 메모리에 배치됩니다. 어쨌든 ..이 변경은 추상적 인 데이터 저장 및 조작에 적합한 경우에만 이루어져야합니다. 나에게 이러한 변화는 선형 대수 토론과 직교합니다.

따라서 APL 슬라이싱 규칙을 구현 하지 않더라도 의미있는 선형 대수를 매우 간단하게 구할 수 있습니다. 당신이 원하는 경우 i 의 일 열 벡터 M 전화 colvec(M,i) 당신은 원하는 경우 i 의 번째 행의 공동 벡터 M 전화를 rowvec(M,i) i 가 튜플이나 벡터라면 튜플이나 벡터 또는 (공) 벡터를 반환 할 수 있습니다 (어떤 경우에는 병렬화에 대한 추론에 유용 할 수 있습니까?). 행렬을 선호하는 경우 일반 색인 표기법을 사용하십시오. APL 슬라이싱 규칙을 사용하는 경우 * 기호로 행 및 열 조각의 동작을 구분하는 데 동일한 방법이 매우 유용합니다. ( rowvec 복잡한 활용이 어떻게 작동하는지 고려해야합니다).

이렇게하면 선형 대수를 수행하는 경우 모든 것이 합리적이며 사용자는 Julia가 구현하는 특정 슬라이싱 규칙에 대해 걱정할 필요가 없습니다. 연산자 ' 는 벡터 및 코 벡터 (장식 변경) 및 행렬 (직접 또는 게으른 방식)에서만 작동합니다. 고유 분해에서 기저 벡터를 추출하는 방법을 기억하는 것이 더 쉬울 수 있습니다.

* 경우 줄리아의 행렬 / 벡터 대수가 작동해야하므로 곱셈 연산자로서의 수학처럼 보이고 느껴지고 두 벡터, 두 개의 코 벡터, 두 개의 행렬 등 사이 의 텐서 곱 연산자를 M*v' 허용해서는 안됩니다. 곱하기 기호를 사용하면 의미가 잘못 정의되었습니다! 행렬 곱셈이 교환 적이 지 않기 때문에 w*M*v' == v'*M*w 가질 수 없습니다. 다시 M*v'*v 경우 * 연관성에 대해 이야기하는 것은 의미가 없습니다. 이것을 두 개의 다른 곱셈 기호가 필요한 innerproduct(outerproduct(M,v'),v) 로 해석하거나 스칼라 곱셈 M * innerproduct(v',v) 로 해석 할 수 있습니다. 여기서 둘 다 * 를 사용하는 것이 _ 적합합니다. 이 표현식을 사용하면 브라케팅이 필요하거나 컴파일러가 의미있는 연산 순서를 검색 할 수 있습니다 (여기서 가장 빠른 평가 순서는 내가 유일한 유효한 평가 순서라고 생각하는 것이기도합니다).

벡터, 코 벡터 및 행렬을 사용하면 표준 수학과 일치하는 대수 시스템을 가질 수 있습니다. 두 벡터 또는 두 개의 코 벡터 또는 두 개의 행렬 사이에서 외적을 수행 할 때마다 본질적으로 다중 선형 대수 또는 일반 텐서 대수로 이동합니다. 여기에 새 기호를 사용하여 kron(M,N) 처럼 곱하는 행렬과 벡터가있을 수 있습니다. 또는 사용자에게 완전한 다중 선형 대수 패키지를 사용하도록 요구할 수 있습니다. 아니면 ... 원래 질문의 범위를 벗어난 것 같습니다 (14 개월 전, btw ...)

요약하자면, 여기에서 거의 완전히 다른 네 가지 일이 발생하는 것을 볼 수 있습니다.

1. APL 슬라이싱 규칙을 사용하여 임의 데이터의 Array 슬라이싱을 개선합니다.
2. 줄리아의 선형 대수는 몇 가지 간단한 개념을 추가하여보다 직관적이고 수학과 완전히 일치하도록 만듭니다. 코 벡터 및 행렬에서 벡터와 코 벡터를 추출하는 방법, 코 벡터, 행렬 등 간의 연산. 많은 사용자는 코 벡터가 존재한다는 사실조차 알지 못할 수 있습니다. 1xn 및 nx1 행렬을 사용하면 예상대로 계속 작동하며 벡터는 동일하게 작동합니다.
3. 속도를 위해 코 벡터와 매우 유사하지만 행렬에 대해서도 랩핑 유형을 사용하여 transpose , conj 등에 대한 지연 평가를 구현합니다.
4. 범용 텐서 패키지를 개발하고 표준 라이브러리에 추가 할 수 있습니다.

아마도 첫 번째 만이 브레이킹 체인지일까요? 나머지는 현재 기능을 개선하거나 추가합니다. 그것들은 모두 어느 정도 독립적으로 구현 될 수 있으며 아마도 모두 할 가치가있을 것입니다. (추신 : APL 슬라이싱을 원하면 Julia가 너무 "커지고"너무 많은 패키지를 깨기 전에 곧 수행하는 것이 좋습니다.)

예, 죄송합니다. M*v' 허용에 대한 제 제안은 제품을 연결하는 다른 방법이 완전히 다른 모양을 생성하기 때문에 실제로 의미가 없습니다. 그래서 우리가 이것을 변경한다면 나의 원래 제안이 갈 길이라고 생각합니다. 지금까지는 APL 슬라이싱 동작과의 최상의 조합 인 것 같습니다. 물론 APL 슬라이싱 동작을 원하는지 여부는 더 높은 수준의 고려 사항입니다.

몇 가지 말씀 드리고 싶은데 소금 한 알과 함께 가져 가세요. 그들은 단지 의견 일 뿐이고 나는 내 것이 그다지 중요하지 않다는 것을 안다. 그러나 @andyferris 댓글을 읽으 감동 시켰습니다 . 선형 대수에 대해 잘 모르지만 Julia에서 데이터를 조작하려는 프로그래머에게는 이해가되어야한다는 의견에 동의하지 않는다고 생각합니다. 저는 프로그래머가 수학 프로그램을 작성해야하는 청중이라고 생각하지 않습니다. 프로그래머가 데이터를 조작하려는 경우이를 수행 할 수있는 많은 언어가 있습니다. Julia는 컴퓨팅 언어이며 정교한 기술 컴퓨팅을 허용해야합니다.

@ esd100 사실, 나는 그것을 생각했다. 하지만 Julia와 함께 저는 우리가 _ 욕심쟁이가되고 싶다고 생각했습니다 .... 많은 목적을 충족시키고 많은 일에 뛰어 들고 싶었습니다. 숫자가 아닌 데이터를 조작하는 데에는 진정한 과학적 이유가있을 수 있습니다. 보다 일반적인 프로그래밍을 원하는 Julia 사용자 인 현재 또는 전 과학자가있을 수 있습니다. 나의 이전 요점은 우리가 Array 느리게 만들거나 조옮김 / 활용에 대해 이야기 할 추가 필드를 제공함으로써 더 많은 메모리를 차지해서는 안된다는 것입니다.

APL 슬라이싱을 수행하는 경우 행 또는 열 슬라이스는 동일한 객체를 반환해야합니다. 질문은 : APL 슬라이싱없이 M[1,:] 가 반환하는 가장 좋은 것은 무엇입니까? 음, M[1,:,:,:,:] 이 Array{T,n} M[1,:] 반환하면 covector{T} 반환하면 모든 사람이 혼란스러워 할 것 같습니다. M = zeros(3,3,3) 하고 현재 1x9 행렬을 반환하는 M[1,:] 호출하면 어떻게 될까요? 이것도 코 벡터로 만들어야합니까? M 이 Array{String,3} 이면 어떻게됩니까?

나에게 이것은 매우 놀랍고 혼란스러워 보일 것입니다. 또한 미래에 발생할 경우 APL 슬라이싱 변경 사항과 일치하지 않습니다. 따라서 선형 대수 목적으로 rowvec(M,i) 및 colvec(M,i) 새로운 함수를 추가 할 것을 제안했습니다. 이상적이지 않고 새로운 함수를 추가하지만 적어도 선형 대수 목적으로 무엇을 반환해야하는지는 분명합니다. 제네릭 배열에 대한 좋은 속성과 선형 대수에 대한 좋은 속성 (코 벡터 유형과 함께)을 가지고 있다고 생각할 수있는 유일한 것이었지만 다중 선형 대수를 수용하려고 시도하지 않았습니다. 행렬에서 코 벡터를 추출하기위한 더 좋은 표기법을 가진 사람이 있다면 좋을 것입니다!

@ esd100 : 프로그래머는 Julia가 디자인 한 청중이라고 확신합니다. 과학 컴퓨팅은 Julias의 강점이지만 범용 프로그래밍 언어로 사용하는 Julia 사용자가 많습니다.

텐서 요구 사항을 컨테이너 요구 사항에서 분리 해야 한다는

전체 스레드를 읽지 않고 내 개인적인 문제는 3D 배열 A (예 : 단층 촬영 데이터)가 있고

imagesc( data[1,:,:] )

이것은 작동하지 않습니다. IMHO data[1,:,:] , data[:,1,:] 및 data[:,:,1] 는 2D 배열 (또는 하위 배열)이어야합니다. 현재이 문제를 극복하기 위해 자체 정의 된 squeeze 함수를 사용합니다.

다시 말하지만 이것은 내가 행동에서 멀리 떨어져 있다는 점을 감안할 때 내 의견 일 뿐이며 매우 중요하지 않은 의견입니다. 나는 응용 프로그램이 개발 될 때 그것을 안내하는 일련의 디자인 원칙을 가져야한다고 느낍니다. 건축업자는 그 목적과 정체성에 대해 명확하고 통일 된 메시지를 보내야합니다. 빠르고 직관적이며 정교한 기술 컴퓨팅 플랫폼을 개발하는 것이 목적이고 그것이 Julia의 강점이라면 그것에 충실하십시오. 목적이 일반 프로그래머의 청중에게 적합하도록하여 혼합 신호를 보내지 마십시오.

요점은 순전히 과학적이거나 수학적 응용 프로그램의 경우에도 몇 가지 상충되는 해석이 있다는 것입니다. 예를 들어 벡터와 행렬을 사용하여 표현할 수있는 여러 수학적 객체가 있으므로 너무 구체적인 선택을해서는 안됩니다.

특정 규칙 집합에 따라 특정 분야의 요구 사항을 충족하기 위해 전용 패키지를 사용하는 것이 좋습니다.

@jutho 내 직감은 당신이 옳다는 것입니다.하지만 패키지가 "더 낫다"고 어떤 대안과 비교했을 때 당신의 결론의 근거가 무엇인지 궁금합니다.

이것은 아주 간단합니다. 대부분의 Julia 사용자에게 중요한 기능은 Base에 속합니다. 보다 특별한 기능은 패키지에 속합니다.

물론 여기에 선을 그리는 것은 그리 쉬운 일이 아닙니다. 그러나 무언가를 기본으로 가져 오는 가장 좋은 방법은 많은 사람들이 이것을 테스트 할 수 있도록 패키지를 만드는 것입니다. Base에 탑재 된 다양한 핵심 기능이 패키지로 처음 개발되었습니다.

@ esd100 , 귀하의 질문을 완전히 이해하지 못했습니다. 결국 과학 언어가 제공해야하는 것은 과학에서 사용되는 전형적인 객체를 표현하고 계산하는 데이터 구조와 방법입니다. 그러나 특정 데이터 구조는 다른 수학적 구조를 나타내는 데 유용 할 수 있으며 때로는 동일한 유형의 객체에 대해 다른 표현이 편리 할 수 ​​있습니다. 따라서 고정 된 수학적 구조를 데이터 유형에 연결하는 것은 일부 분야에서는 너무 제한적일 수 있고 다른 분야에서는 너무 복잡 할 수 있습니다. 따라서 이것은 Julia 기지에서 추구하는 것이 아니라 한 분야의 요구를 충족시키려는 특정 패키지에 의해 추구되어야합니다.

현재 논의와 관련하여 벡터와 행렬로 작업하는 모든 사람은 벡터를 전치하고 v ^ T * w = 스칼라를 가질 가능성을 기대할 것입니다. 그러나 이러한 벡터와 행렬은 여러 가지를 나타내는 데 사용될 수 있으며 이는 아마도 분야 / 분야에 따라 달라질 것입니다. 위의 게시물에서 v ^ T가 실제 코 벡터가 아닐 수있는 예를 제공했습니다.

2015 년 1 월 11 일 18:10에 esd100 [email protected] 은 다음과 같이 썼습니다.

@jutho https://github.com/jutho 내 직감은 당신이 옳다는 것입니다.하지만 패키지가 "더 낫다"고 어떤 대안과 비교할 때 당신의 결론의 근거가 무엇인지 궁금합니다.

—
이 이메일에 직접 답장하거나 GitHub https://github.com/JuliaLang/julia/issues/4774#issuecomment -69501771에서

이것은 아주 간단합니다. 대부분의 Julia 사용자에게 중요한 기능은 Base에 속합니다. 보다 특별한 기능은 패키지에 속합니다.

그렇게 간단하지 않다고 생각합니다. 예를 들어 Base에는 Bessel 함수가 있으며 대부분의 Julia 사용자에게 중요 할 가능성은 거의 없습니다. 그들이 Base에있을 수있는 이유는 Bessel 함수가 무엇인지에 대해 합리적으로 보편적 인 표준이 있고, 누구도이 이름을 다른 것에 사용하거나 다른 것을 기대하지 않기 때문입니다.

신중한 이름 지정 규칙을 통해 Mathematica는 핵심 언어에 4000 개 이상의 함수를 넣을 수 있으며 패키지를로드 할 필요가 거의 없다는 것이 매우 편리하다는 것을 알게되었습니다. 대조적으로, 내가 Python / Sage를 사용할 때, 하나의 파일 / 노트북이 상단에 200 개의 함수를 명시 적으로 가져 오는 것은 드문 일이 아닙니다 (추적 불가능한 "from ___ import *"구문을 피함). 내장되지 않은 함수를 사용해야 할 때마다 몇 가지 추가 단계를 거쳐야합니다.

(1) 해당 파일에서 이미 사용했는지 기억하거나 텍스트 검색을 수행하여 확인합니다 (이름이 다른 항목의 하위 문자열 인 경우 전체 단어로 제한).
(2) 다음 중 하나 : (a) 즉시 수입품을 추가하여 내 생각을 잃고 다시 찾는다. 또는 (b) 내가하던 일을 한 후에 가져 오기를 추가하는 것을 기억하고 다른 일을 메모리에 보관하십시오.
(3) 덜 일반적인 기능의 경우 어떤 패키지에 들어 있는지 찾아야 할 수 있습니다.

이것은 짜증나고 쇠약해질 수 있습니다. 그래서 저는 Bessel 함수와 같이 표준으로 간주되는 모든 것 (따라서 이름 충돌이나 혼동을 일으키지 않습니다)은 많은 사람들이 사용하는지 여부에 관계없이 Base에 있어야한다고 생각합니다. 확실히 선형 대수.

다시 주제로 돌아가서, 의미 론적으로 베어 컨테이너 ( Base.AbstractArray 에서 구현 됨)로서의 배열에서 up / down 시맨틱이있는 Cartesian 텐서 객체 (my에서 설명한대로)에 대해 여러 계층의 기능에 대해 이야기했습니다. AbstractTensorArray 제안 , 벡터 공간 ( @Jutho 의 TensorToolbox 에서와 같이)에 매핑 된 인덱스가있는보다 일반적인 텐서 객체에 대한 일반성 증가 및 최적화 잠재력 감소.

사용자가 이러한 계층간에 쉽게 전환 할 수있는 것이 중요하다고 생각합니다. 사용자가 시작할 때 실제로 필요한 일반성 수준을 _ 모를 수도 있기 때문입니다. 간단한 예로서 @Jutho 는 @jdbates 의 이미지 처리 예에서 사용자가 다른 방법으로 이미지 좌표를 처리하고 다른 방법으로 색상 공간을 처리하기 위해 서로 다른 인덱스 하위 집합을 별개의 기하학에 연결하기를 원할 수 있다고 지적했습니다 . 그러나 기하학적으로 이들 중 하나만 사용하기 시작했다면 각각 고유 한 지오메트리와 함께 사용할 수있는보다 일반적인 표현으로 업 캐스트하는 것이 편리 할 것입니다. 각 일반성 수준에서 시작되는 추가 함수 (또는 함수 호출 패턴)가 합리적인 기본값을 사용하는 경우 (예 : AbstractTensorArray s의 업 / 다운 인덱스 및 중립 인덱스를 단일 기본 데카르트 벡터 공간 및 "시퀀스"공간은 각각 --- 그러면 거의 매끄럽게됩니다. 하위 기능 계층의 사용자는 필요할 때까지 상위 계층에 대해 알거나 신경 쓸 필요가 없습니다.

관련 사용자에게 명확하고 예측 가능한 부분은 계층 구조가 무엇인지 합리적으로 Base에 들어갈 수 있습니다. 진짜 질문은 --- 배열 연산이든 선형 대수이든 텐서 대수이든 ---이 유형의 기능을 가진 사용자가 다른 방식을 기대하거나 원할 가능성은 얼마나됩니까?

많은 사람들이 Python-land에서 작업을 수행하기 위해 얼마나 많은 수입품이 필요한지에 대한 어리석은 세분성을 싫어합니다. 저는 아무도 그 정도 길이로 갈 것을 제안하지 않는다고 생각합니다.

그러나 많은 수의 종속성과 라이브러리 팽창이 일부 사용 사례에서 바람직하지 않다는 중요한 주장이 있습니다. Julia 언어는 실제로 컴퓨터에 Fortran 런타임 라이브러리를 설치할 필요가 없어야하지만 현재 Julia 표준 라이브러리가 수행하는지 여부에 관계없이 실행하려는 코드는 선형 대수 (또는 Bessel 함수 또는 FFT 등)를 수행하는 것입니다. 이것은 모두 # 5155 및 기타 문제에 의해 잘 다루어집니다. "기본적으로 설치됨"및 "모든 기능에 필요한 최소값"은 결국 서로 다른 모듈 세트로 분리되어야합니다.

감사합니다 Tony, 두 번째입니다. 또한, 우리의 패키지 시스템을 사용하면 여러 그룹을 함께 그룹화하는 패키지와 같은 "도구 상자"를 갖는 것이 실제로 문제가되지 않습니다. @reexport 매크로를 사용하면 잘 작동합니다.

그러나 또 다른 요점이 있습니다. 패키지 내에서 아이디어를 추진하는 것이 훨씬 쉽습니다. 무언가를 바꾸고 싶다면 그냥하세요. Base one 내에서 훨씬 더 제한적입니다.

패키지 패치 워크를 사용하면 독립성을 높일 수 있지만 탐색하기 더 어려운 단편화 된 플랫폼이 생성됩니다. 보다 통일되고 일반화 된 구조를 사용하면 분야 간 상호 작용과 새로운 영역 탐색을 간소화하고 용이하게 할 수 있습니다.

현재 벡터 * 행렬을 수행하는 가장 관용적 인 방법은 무엇입니까?
예 내가있어 말을 X 모양으로 (K, N) 및 b 모양 (K,) , 그리고 곱셈에 의해 원하는 b 온 길이가 (N,) 벡터를 얻으려면 왼쪽.
BLAS.gemv('T',1.0,X,b) 전화하나요
또는 reshape(b'*X,size(x,2))
둘 다 약간 못 생겼습니다.

X'b 할 수있을 것 같아요

2015-03-13 17:15 GMT-04 : 00 joschu [email protected] :

현재 벡터 * 행렬을 수행하는 가장 관용적 인 방법은 무엇입니까?
예를 들어 X는 모양 (K, N), b에는 모양 (K)이 있고
길이 (N,)의 벡터를 얻기 위해 왼쪽에 b를 곱합니다.
BLAS.gemv ( 'T', 1.0, X, b)를 호출합니까?
또는 reshape (b '* X, size (x, 2))
둘 다 약간 못 생겼습니다.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.
https://github.com/JuliaLang/julia/issues/4774#issuecomment -79405868.

그래, 나는 그것이 X의 복사본을 유발할 것이라고 생각했다.
그러나 @time 은 메모리 할당에 따라 사본이 없음을 나타내는 것 같습니다.

julia> X = rand(1000,1000); y = rand(1000);

julia> <strong i="8">@time</strong> y'X;
elapsed time: 0.00177384 seconds (15 kB allocated)

julia> <strong i="9">@time</strong> X'y;
elapsed time: 0.000528808 seconds (7 kB allocated)

우리는 '의 멋진 구문 분석을 수행하므로 X'y 는 Ac_mul_B(X,y) 로 끝나고
당신이 제안한 것과 동일한 BLAS 전화.

2015-03-13 17:28 GMT-04 : 00 joschu [email protected] :

그래, 나는 그것이 X의 사본을 유발할 것이라고 생각했지만.
(하지만 @time https://github.com/time 은
메모리 할당에 따라 복사

줄리아> X = rand (1000,1000); y = rand (1000);

줄리아> @time y'X;
경과 시간 : 0.00177384 초 (15kB 할당)

줄리아> @time X'y;
경과 시간 : 0.000528808 초 (7kB 할당)

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.
https://github.com/JuliaLang/julia/issues/4774#issuecomment -79421713.

믿거 나 말거나이 전체 스레드에 대한 글이 구체화에 가까워지고 있습니다.

마지막 요점 : 누군가 그것을 고려한 적이 있습니까? ' 실제로 '?'와는 완전히 다른 동물 일 수 있습니다. 후자는 이중이되기위한 올바른 구조를 가지고 있지만. ' 기본 필드가 실수가 아니면 그렇지 않습니다. 할당하는 것이 미쳤습니까? ' 이원성의 모든 개념을 '로 전치하고 예약하는'모든 인덱스 역전 '개념은 "재미있는 행 벡터"/ 헤르 미트 켤레를 생성합니까?

어쨌든 conj(transpose(x)) 는 ctranspose(x) 와 동일해야한다고 생각합니다.

위의 주장대로, 내가 그 래퍼 유형의 비 희망 transpose 및 ctranspose 와 같은 특정 수학적 개념을 포함하는 이름이 주어집니다 만들 것입니다 dual . Julia와 같은 과학적 언어는 유용한 데이터 구조 세트를 제공하고 공통 연산을 구현해야하지만 엄격한 수학적 구조를 여기에 연결하는 것은 실수라고 생각합니다. 이는 일부 응용 프로그램에는 적합하지 않고 너무 복잡하기 때문입니다. 기타. 이러한 데이터 구조 및 연산을 사용하여 응용 프로그램에서 수학적 연산을 구현하는 것은 사용자에게 달려 있습니다. z 가 복소 벡터이고 A 일부 행렬을 반환하는 스칼라를 반환하는 z.' * A * z 대한 응용 프로그램이 있습니다. 비록 이것이 내부 곱 및 / 또는 이중과 관련이 없더라도 벡터.

@jutho z.' * A * z 대한 사용 사례를 제공 할 수 있습니까?

z1 및 z2 가 두 개의 복잡한 벡터 Z1 및 Z2 (예 : Kähler 매니 폴드의 접선 공간의 홀로 모픽 부분에있는 접선 벡터 ) 및 a 는 두 개의 공변 인덱스 (예 : Kähler 매니 폴드의 복잡한 (2,0) 형식)가있는 텐서 A 의 행렬 표현이고 A(Z1,Z2) = z.' * a * z 입니다.

여기서 강조하는 것은 줄리아 개체 z1 , z2 및 a 는 특정 수학적 개체의 _ 표현 _ (선택된 기준 / 조정과 관련하여) 만 형성하므로 데이터 구조에 대한 연산은 이러한 데이터 구조가 무엇을 나타내는 지 모른 채 수학적 연산과 고유하게 연관 될 수 없습니다.

@jutho 감사합니다. 표현에 대한 귀하의 요점은 잘 받아 들여졌으며이 토론에서 여러 번 표현되었습니다. 저는 벡터와 행렬의 최소 인터페이스를 찾고, 그 최소 인터페이스가 배열의 최소 인터페이스와 근본적으로 호환되지 않는지, 그리고 사용자 정의 추상 데이터 유형으로 오프로드 할 수있는 것을 확인하려고합니다.

이 시점에서 저는 @StefanKarpinski 제안에 전적으로 찬성합니다. 위의 @andyferris 도 대부분 반향합니다. 특히

1. APL 스타일 인덱싱
2. v '는 일종의 Covector 또는 Transpose 유형을 제공합니다.

다른 모든 것은 세부 사항입니다. row(M,i) 및 col(M,i) 함수를 추가하는 것이 좋습니다. 그렇지 않으면 행을 코 벡터로 추출하려면 M[i,:].' 가 필요할까요? IIUC, M[i,:]' 는이 경우에 원하지 않는 conj 할까요?

예, 제가 마지막으로 작성한 APL 스타일 인덱싱의 좋은 점을 충분히 인식하지 못했지만 지금은 그 변경을 전적으로 지원하고 있습니다. 이것은 차례로 이중 벡터를 더욱 매력적으로 만들고 row / col 함수를 만듭니다.

그 이후로 나는 구현을 가지고 놀아 보았고 가장 혼란스러운 것은 행렬에서 추출 된 covector가 공액인지 아닌지였습니다.

나는 당신이 행렬의 리터럴 값을 원한다고 생각합니다. Dirac 표기법을 사용하여 (모든) 행렬 확장 M = sum_i | i>예를 들어 [0,0,1, ..., 0], 우리는U 우리는 고유 분해에서 왼쪽 및 오른쪽 고유 벡터를 추출하는 데 완벽한 의미가있는 row(U,i)' = col(U’,i) 를 얻습니다.

앤디

2015 년 3 월 15 일 오후 9시 36 분에 Jeff Bezanson [email protected] 은 다음과 같이 썼습니다.

이 시점에서 나는 @StefanKarpinski에 찬성 완전히 해요 https://github.com/StefanKarpinski 또한 대부분 @andyferris에 의해 에코, 제안 https://github.com/andyferris 위. 특히

APL 스타일 인덱싱
v '는 일종의 Covector 또는 Transpose 유형을 제공합니다.
다른 모든 것은 세부 사항입니다. row (M, i) 및 col (M, i) 함수를 추가하는 것이 좋습니다. 그렇지 않으면 행을 코 벡터로 추출하려면 M [i ,:]이 필요합니다. ' ? IIUC, M [i ,:] '이 경우 원하지 않는 conj를할까요?

—
이 이메일에 직접 답장하거나 GitHub https://github.com/JuliaLang/julia/issues/4774#issuecomment -81228816에서

이 작업을 시작할 자원 봉사자가 있습니까? 예를 들어 @mbauman , @jakebolewski 가 놀랍게도 이미이 스레드에 없습니다. :)

변경해야하는 모든 것을 찾는 것은 지루할 수 있지만 인덱싱 동작에 대한 기본적인 변경은 그리 나쁘지 않아야합니다. 아마도 @jiahao 와 @andreasnoack 은 Covector를 통합하는 방법에 대해 더 많이 말할 수 있습니다.

이 작업을 진행하려면 9 개, 8 개 더 이상의 주석이 필요합니다.

제가 도와 드릴 수 있습니다.

우리는 꽤 가깝습니다

관련 주석으로 Transpose 및 CTranspose 래퍼 유형이있는 경우 conj(A) 와 같은 일반 Conjugate 래퍼 유형이어야합니다. 또한 게으른. 행렬을 BLAS로 곱하는 경우에는 특별한 지원이 없기 때문에 실제로 유용하지 않습니다 (BLAS의 C 는 hermitian conjugate를 의미 함). 전체 Julia BLAS 구현이 있다면 지원하는 것도 좋습니다. 명시 적 활용없이 conj(A)*B .

저는 예전보다 훨씬 더 진지하게 벡터 전치를 취하는 것처럼 느껴집니다.

아마도 @andreasnoack 과 @simonbyrne 은 # 6837을 다시 방문해야하는지 알려줄 수 있습니다.

Transpose{Array} <: AbstractArray 이 (가) 없어야한다는 @simonbyrne에 동의합니다.

기타 일반적인 생각 :

• 외부 곱 계산에 현재 "후행 단일 치수를 자동으로 추가하지 않음"규칙에 대한 예외가 포함되어 있음을 깨달았습니다. u 크기가 (n,) 경우 u * u' 는 (n,) x (1, n) 와 관련된 계산입니다. 이 곱은 행렬 곱셈의 일반적인 규칙을 사용하여 계산할 수 없습니다. _unless_ 첫 번째 인수를 (n, 1) 으로 자동 변경하지 않는 한.
• MATLAB 인덱싱 의미 체계의 "후행 단일 차원 자동 추가"규칙은 "전치가 모든 차원을 반전 함"규칙과 근본적으로 호환되지 않습니다. 이전 규칙을 사용하면 (n,) 모양의 배열은 (n,1) 모양 및 모양 (n,1,1) 등의 모양을 변경 한 배열과 의미 상 동일합니다.하지만 조옮김이 모든 차원을 반전하면 결과 배열의 모양은 (n,) , (1, n) 및 (1,1,n) 이며, 후행 싱글 톤 만 추가 할 수있는 경우에는 동등 할 수 없습니다 _. 이를 논리적 극단으로 가져 가면 배열의 전치가 임의의 수의 _leading_ 싱글 톤을 가질 수 있으므로 논리적으로 일관성이없는 모호한 모양을 갖습니다.

나는 또한 문헌 조사를했고 흥미로운 APL 역사를 발견했습니다. 우리가 APL 인덱싱 규칙이라고 부르는 것은 Iverson의 1962 책이 아니라 APL \ 360 (1968, APL의 첫 번째 구현)에 존재했습니다. 그러나 APL \ 360은 스칼라와 1- 벡터를 합쳐서까지 문헌에서 인식되지 않았던 불일치이다 (Haegi, 1976). 다차원 배열의 형식적 의미론에 대한 논의는 Brown의 PhD 논문 (1972; 나중에 APL2를 설계 함)에 처음 등장했으며, 의미론을 형식화하는 일련의 작업에 박차를가했습니다.

APL2로 이어지는 개발에 대한 훌륭한 설문 조사는 다음과 같습니다.

• Karl Fritz Ruehr. "APL 확장에 대한 설문 조사." APL에 관한 국제 컨퍼런스, APL '82, 페이지 277–314, 미국 뉴욕 주 뉴욕, 1982 년 ACM.

색인 규칙에 대한주의를 기울인 문헌에서 주목할만한 사항은 다음과 같습니다.

• T. 더. "배열 이론에 대한 공리와 정리." IBM Journal of Research and Development, 17 (3 월) : 135–175, 1973.
  
  
  
  • Quine의 공리적 집합 이론을 사용하여 다차원 배열의 의미를 공식화하는 거대한 책. APL 문헌에서 "부동 배열"이라고 부르는 것을 구성하기 위해 자체 포함 집합의 개념을 사용하여 스칼라를 순위 0 배열과 결합하는 방법을 보여줍니다. ([1] == 1, 여기서 [1]! = 1. "접지 된 배열"과 대조되는 [1]! = 1. 나중에 Sheila M. Singleton이 1980 년 석사 논문에서 작업 한 결과 More의 배열 이론은 접지 된 배열을 설명하는 데에도 적용될 수 있음을 보여주었습니다.)
  
  
  • More는 또한 배열 의미론을 안내하는 중요한 규칙으로 스칼라를 반환하는 내부 곱을 언급합니다.
  
  
  • 또한 일반적인 다차원 배열에 대한 "업 / 다운"처리의 복잡성을 암시합니다.
    
    "V를 필드에 대한 n 차원 벡터 공간이라고합시다. 반 분산 및 공분산의 고려 사항을 무시하고 V의 원자가 q 텐서는 목록 VV ... V의 데카르트 곱을 벡터로 다중 선형 매핑 한 것입니다. V에 밑이 있으면 V에있는 valence q의 텐서는 길이가 n 인 q 축에있는 배열 인 _component tensor_로 나타낼 수 있습니다. "
  
  
• G. 루이스. "APL을위한 새로운 어레이 인덱싱 시스템", APL에 관한 제 7 차 국제 회의 절차-APL '75, 234-239, 1975.
  
  
  
  • 이 논문은 인덱싱 작업에서 인덱스 튜플을 APL에서 일류 객체로 옹호 한 최초의 문서이며 인덱스 튜플의 각 순위에 따라 체계적인 데카르트 곱을 통해 인덱싱 결과의 일관된 구성을 달성 할 수 있다고 언급했습니다.
  
  
• Hans R Haegi. "트리와 같은 데이터 구조로의 APL 확장." ACM SIGAPL APL 견적 쿼드, 7 (2) : 8–18, 1976.
  
  
  
  • 이 논문은 스칼라와 1- 배열을 합친 고전적인 APL \ 360의 불일치에 대해 불평하고 APL 인덱싱 규칙이이 합병이 유지되지 않도록 요구한다고 주장했습니다.
  
  
  • 이 논문은 또한 1975 년 Lewis와 매우 유사한 구조를 포함하고 있습니다. 작업은 독립적 인 것처럼 보입니다.
  
  
• JA Gerth 및 DL Orth. "APL에서 인덱싱 및 병합." APL에 관한 국제 회의 회보, APL '88, 156–161 페이지, 미국 뉴욕, 뉴욕, 1988. ACM.
  
  
  
  • APL 인덱싱 규칙은 인덱스 집합을 값 집합에 매핑하는 방송 작업으로 인덱싱을 생각하면 정당화 될 수 있습니다. 이 기능적 해석은 자연스럽게 순위 보존 규칙과 루이스와 해기의 데카르트 구성을 암시한다.
  
  

또한 "후행 단일 치수 추가 가능"규칙이 없으면 우리는

왼쪽은 스칼라 (트레이스 정의에 따라)이고 오른쪽은 (1, n) x (n, n) x (n,) = (1,) 모양이기 때문입니다. 반대로, 벡터 전치 의미론을 선택하기위한 지침 원칙으로이 정체성을 취할 수 있습니다. 요점은 첫 번째 ID를 정의하는 추적 작업의 순환 속성입니다. 트레이스 내부의 수량은 스칼라 또는 행렬이어야합니다 (벡터 트레이스는 정의되지 않음). Avv' 은 (는) 이미 모호하지 않은 행렬입니다. (Av)v' 및 A(vv') 는 동일한 결과를 생성합니다. 그러나 두 번째 수량에서도 v'Av 는 행렬 _ 또는 _ 스칼라 여야합니다. (스칼라 인 경우 두 번째 항등도 유지됩니다.) v'Av 는 "후행 단일 차원을 추가 할 수 있음"규칙이 활성화 된 경우에만 1- 벡터가 될 수 있으며,이 경우 투명하게 1x1 행렬로 모양을 변경할 수 있습니다.

따라서 추적을 정의하려면 외부 제품 vv' 및 2 차 형식 v'Av 의 허용 가능한 모양에 대해 반드시 제한을 부과합니다.

@jihao : 나는 당신이 우리에 대해 무엇을 주장하고 있는지 잘 모르겠습니다. "후행 단일 치수 규칙을 추가 할 수 있음"을 좀 더 명확하게 말할 수 있습니까? 언제 적용 되나요? 우리가 그것을 지원해야한다고 생각합니까?

전치가 모든 차원을 역전시키는 것으로 생각할 수없는 입장을 강화하기 위해 일부 주장을 취할 수 있다고 생각합니다 (열 벡터는 열 벡터로 전치되거나 임의의 수의 선행 싱글 톤 차원이있는 배열로 전치 됨). 행렬 대수와 일관성을 유지하려면 대신 두 개의 첫 번째 차원을 바꾸는 것으로 간주해야한다고 생각합니다. 그러면 나는 당신이 말하는 모순 중 일부가 사라진다고 믿습니다. 전치 할 때 싱글 톤 차원을 추가하지 않으면 나머지는 사라질 것입니다 (코 벡터의없는 첫 번째 차원은 계산되지 않음).

위의 일반적인 의견은 이러한 규칙을 옹호하는 것이 아니라 배열 인덱싱 규칙의 설계 공간과 선형 대수 ID와의 상호 작용을 설명하는 데 도움이됩니다.

"후행 단일 차원 추가 가능"규칙은 MATLAB에서 사용되며 (@alanedelman에 따라) 다차원 배열을 지원하기 위해 도입되었습니다. MATLAB 배열에 사용되는 인덱스-오프셋 계산은 sub2ind 로 정의되며, 이는 사용자가 후행 1을 몇 개 던 졌는지에 관계없이 동일한 선형 인덱스를 반환합니다. 또한 MATLAB의 행렬 인덱싱 문서 에는 인덱싱 작업에 대해 다음과 같이 설명되어 있습니다.

1과 같은 후행 첨자를 포함하지 않고 B에 지정된 첨자의 수는 ndims (B)를 초과하지 않습니다.

더 공식적으로 다음과 같이 말할 수 있다고 생각합니다.

배열을 입력으로 사용하는 연산의 경우 (n,) -arrays, (n,1) -arrays, (n,1,1...) 배열은 이러한 연산에 대한 유효한 인수라는 점에서 모두 동일한 등가 클래스에 있습니다. ( n=1 인 경우 등가 클래스에는 스칼라도 포함됩니다.)

예 :

• A*b 및 A\b 여기서 A 는 행렬이고 b 는 벡터 또는 행렬 일 수 있습니다 ( n x 1 행렬에 대한 동일한 의미).
• hcat(A, b) 여기서 A 는 행렬이고 b 는 벡터 또는 행렬 일 수 있습니다.

대부분의 경우 Julia는 외부 제품 예제를 제외하고 "후행 단일 치수를 추가 할 수 있음"규칙이 없습니다. 다른 사람도있을 수 있지만 지금은 생각할 수 없습니다.

Transpose{A<:AbstractArray} 이 AbstractArray 의 하위 유형이 아닌 한 나는 문제가 없다고 생각합니다 (하지만 여러분만큼 생각하지 않았기 때문에 뭔가 간과하고있을 것입니다) :
와

typealias AbstractVectorTranspose{A<:AbstractVector} Transpose{A}
typealias AbstractMatrixTranspose{A<:AbstractMatrix} Transpose{A}
typealias AbstractTMatrix Union(AbstractMatrix, AbstractMatrixTranspose} 

(그리고 유사하게 CTranspose ) 우리는

AbstractVectorTranspose * AbstractVector = Number
AbstractVector * AbstractVectorTranspose = AbstractMatrix
AbstractVectorTranspose * AbstractTMatrix = AbstractVectorTranspose
AbstractTMatrix * AbstractVector = AbstractVector
AbstractTMatrix * AbstractTMatrix = AbstractTMatrix

유일한 열린 질문은 AbstractTMatrix 첫 번째 크기가 1 AbstractVector * AbstractTMatrix 가 지원되어야하는지 또는 AbstractVector * AbstractVectorTranspose 가 충분한 지 여부입니다.

또한 새로운 유형 시스템은 typealias 및 union sa 중 일부를 좀 더 신중하게 표현하는 데 도움이 될 수 있습니다.

또한 v.'*A 가 (A.'*v).' 로 계산되는 경우 A 자체가 A=B' 이면 A Conjugate 래퍼가 필요합니다. .

Transpose{Array} <: AbstractArray 이 (가) 없어야한다는 @simonbyrne에 동의합니다.

거기에 대해 자세히 설명해 주시겠습니까? https://github.com/JuliaLang/julia/issues/4774#issuecomment -59428215의 의견은 CoVector가 AbstractVector의 하위 유형이되어서는 안된다고 생각했지만 Transpose{Matrix} <: AbstractArray 하지 않는 것이 조금 이상하게 보일 것입니다.

무엇의 가치를 위해, 나는 생각 CoVector 대부분처럼 행동한다 Vector 것을 제외하고 Vector 로 변환 Matrix 로 열 매트릭스 동안 CoVector 는 Matrix 로 행 행렬로 변환됩니다.

covector에 대한 인덱싱이 행 행렬과 동일하게 작동해야 함을 의미합니까?

흥미로운 생각입니다. 전치 / 코 벡터 유형에서 _leading_ 싱글 톤 차원 만 삭제하면 일이 더 쉬워 지거나 복잡해 집니까?

(나는 관심을 가지고이 문제를 따라 왔지만 내 선형 대수는 충분히 녹슬 어서 기여할 자격이 없다고 느꼈습니다).

@mbauman :

전치 / 코 벡터 유형에서 선행 단일 차원 만 삭제하면 일이 더 쉬워 지거나 복잡해 집니까?

임의의 수의 선행 싱글 톤 차원을 허용하면 배열 인덱스가 더 이상 잘 정렬되지 않고 ""첫 번째 차원과 같은 것이 없습니다. 이것은 우리가 공리로 잘 정렬 할 수있을만큼 기이 할 정도로 기이합니다.

@tkelman :

# 4774 (코멘트)의 의견은 CoVector가 AbstractVector의 하위 유형이되어서는 안된다고 생각했지만 Transpose {Matrix} <: AbstractArray를 사용하지 않는 것이 조금 이상하게 보일 것입니다.

이 문제는 전적으로 선형 대수 의미론에서 배열 의미론 (cf # 10064 참조)을 분리하고 혼합 된 장소를 찾는 것에 관한 것임이 분명해졌습니다.

• 배열 의미론은 size, length, getindex, setindex, hcat, vcat, reshape, rot90 ...과 같은 함수로 정의됩니다.
• 선형 대수 의미론은 +,-, *, /,, ', trace ...와 같은 함수로 정의됩니다.

cat 함수를 AbstractArray 의 필수 인터페이스의 일부로 정의하면 cat Transpose{<:AbstractArray} 는 연결 동작이 다르기 때문에 분명히 AbstractArray 가 아닙니다. . 모양과 인덱싱 만 필수 인터페이스의 일부로 간주하면 상황이 명확하지 않습니다.

우리는의 필수 인터페이스의 일부로 연결이 필요한 경우 AbstractArray , 정당화도 쉽게 왜 같은 종류의 SymTridiagonal 되어 있지 AbstractArray 이상 연결 작업 이후의, SymTridiagonal 유사한다 [SymTridiagonal(randn(5), randn(4)) randn(5)] 현재 정의되지 않은 있습니다.

@toivoh :

covector에 대한 인덱싱이 행 행렬과 동일하게 작동해야 함을 의미합니까?

Transpose{Vector} 의 인덱싱 동작이 일반 Vector 와 동일해야한다고 제안하는 ID가 있습니다. 숫자 유형의 경우 v[1] 는 v' * e₁ = v ⋅ e₁ 와 동일한 결과를 생성하고 v[1:2] 는 v' * [e₁ e₂] 와 동일한 결과를 생성합니다. 여기서 e₁ 는 표준 베이시스 Vector{Int} [1, 0, 0, ...] 및 e₂ 는 [0, 1, 0, 0, ...] 입니다. 인덱싱, 내부 제품 및 조옮김과 관련된 이러한 신원을 유지해야한다면 다음과 같이 주장 할 수 있습니다.

(v')[1] == (e₁' * v'') == (v' * e₁)' == (v ⋅ e₁)' == conj(v ⋅ e₁)* = conj(v[1])

(첫 번째 단계는 새로운 공리이고 네 번째 단계는 스칼라를 전치하는 것이 작동하지 않는다는 사실을 활용합니다) Transpose{Vector} 로 인덱싱하면 본질적으로 전치가 무시되고 CTranspose{Vector} 로 인덱싱됩니다.

나에게이 문제는 전적으로 선형 대수 의미론에서 배열 의미론 (cf # 10064 참조)을 분리하고 혼합 된 장소를 찾는 것에 관한 것입니다.

• 배열 의미론은 size, length, getindex, setindex, hcat, vcat, reshape, rot90 ...과 같은 함수로 정의됩니다.
• 선형 대수 의미론은 +,-, *, /,, ', trace ...와 같은 함수로 정의됩니다.

해당 관점에 +1하고 Transpose <: AbstractArray . 또한, covector를 인덱싱 할 때는 단일 인덱스를 사용해야합니다. 그렇지 않으면 covector * 벡터 (단일 인덱스에 대한 축소)의 결과가 스칼라 (인덱스가 0 인 객체)가 될 수 없기 때문입니다.

@jihao : 왜 우리가 필요하거나 원하는지 잘 모르겠습니다.

(v')[1] == (e₁' * v'')

새로운 공리로. covector가 행 행렬로 인덱싱하더라도 선형 인덱싱으로 인해 위와 동일한 결과를 얻을 것이라고 생각합니다.

선형 대수와 관련하여 코 벡터를 보는 데 +1합니다.

하지만 SymTridiagonal 와의 연결을 정의해서는 안 될 이유가 없죠?

배열에 대한 @toivoh 선형 인덱싱은 먼저 배열을 벡터로 재구성 한 다음 새 벡터를 인덱싱하여 정의됩니다. 따라서 선형 인덱싱이 전치 배열에 대해 동일한 결과를 제공하려면 전치 벡터에 대한 인덱싱 규칙을 먼저 정의하여 선형 인덱싱 규칙을 파생시킬 수 있어야합니다. (또한 다른 사람에게 핑을 보냅니다.)

선형 인덱싱이 저장 순서에 관한 것이라고 생각했는데, 어쨌든 벡터의 선형 인덱싱을위한 다른 합리적인 순서는 없습니다. (맞춤법 오류에 대해 죄송합니다.)

메모리에는 고유 한 순회 순서가 없습니다. Fortran 배열의 경우에도 주요 열, 주요 행 또는 역열 주요 순서로 요소를 저장하도록 선택할 수 있습니다 (원래 IBM Fortran I 컴파일러가 수행 한 것과 동일 함). 또한 배열로 사용할 수 있고 순회 순서에 대한 더 많은 옵션이있는 try와 같은 다른 데이터 구조 (# 10064 참조)가 있습니다.

벡터와 행렬에 대해서도 마찬가지입니다. 선형 인덱싱은 열 행렬과 전치 (열 벡터의 경우와 동일)에 대해 동일한 순서로 요소에 액세스하기 때문에 코 벡터가 달라야하는 이유는 무엇입니까? 달라야한다면 코 벡터에 대한 인덱싱을 전혀 정의하지 않아야한다고 생각합니다.

@toivoh 예 일반 배열에 대해 동일한 정의가 유지됩니다. 두 경우 모두 선형 인덱싱이 일반 (튜플?) 인덱싱에서 파생된다는 사실은 변경되지 않습니다.

Transpose 개체 인덱싱이 허용되지 않을 수 있습니다. 인덱싱이 가능해야한다는 말은 아니지만 인덱싱이 가능하다면 반드시 동일한 인덱싱 동작을 가질 필요는 없습니다. 보수적으로 인덱싱을 정의하지 않은 채로두고 사용 사례가 나타나는지 확인할 수 있습니다.

선형 대수 함수의 많은 순수 Julia 구현은 Transpose로 인덱싱하기를 원할 것입니다. 관련된 두 행렬에 대해 가능한 대소 문자 (normal, transpose, ctranspose, conj?)를 구분할 필요가 없지만 일반 행렬로 취급하면 순수 Julia 행렬 곱셈 (BLAS가 아닌 숫자 유형의 경우)을 쉽게 작성할 수 있습니다. 약간의 로컬 메모리 액세스 패턴을 얻기 위해 캐시 인식 방법을 시도 할 수 있습니다.

맞아.

@Jutho : 동의합니다. 그리고 거기에 맞추려면 코 벡터는 행 행렬처럼 인덱싱해야합니다.

@toivoh , 그들이 앞에 여분의 인덱스 1이 있다는 것을 의미한다면, 나는 동의하지 않으며 그것이 내 진술에서 어떻게 암시되는지 보지 못합니다. 매트릭스 매트릭스 제품에 대해서만 이야기했습니다. Matrix * vector 또는 covector * matrix는 메모리 액세스 패턴이 다르기 때문일뿐만 아니라 반환 유형이 다르기 때문에 (Matrix_vector = vector 또는 covector_matrix = covector) 다른 함수 정의가 필요한 다른 방법이므로 ther은 줄리아에서 이러한 것들을 혼합하지 않는 매우 실용적인 이유.

일반적으로 저는 N 차원 배열을 인덱싱 할 때 추가 인덱스 1을 추가하는 능력이나 예를 들어 VecOrMat 유형 별칭을 추가하는 기능을 좋아하지 않습니다. 이것은 엉성한 프로그래밍을 허용하지만 실수를 저 지르거나 다른 실수를 더 느리게 감지 할 수있는 이유이기도합니다. 텐서 곱의 벡터로 처리 할 때 다중 선형 객체로 사용하거나 선형 인덱스를 사용하는 경우 정확한 N 인덱스를 사용하여 N 차원 배열을 inex하는 두 가지 유용한 방법 만 볼 수 있습니다. 공간 (예 : 이러한 배열 두 개를 더하거나 스칼라를 곱하는 경우). 내 사용 caes에는 충분하지만 다른 사람에게는 제한적이라는 것을 받아 들일 수 있습니다.

@Jutho : 좋아, 어쨌든 반환 유형이 달라야하기 때문에 아마도 중요하지 않다는 데 동의합니다.

다음은 우리가하려는 작업을 설명하고 몇 가지 공리를 부여하려는 시도입니다.

출발점이 행렬 대수 (행렬만을 기반으로 함)라는 매우 명확한 합의에 도달했다고 생각합니다. 대부분의 작업의 경우 순수 행렬 설정에서 어떻게 작동하는지 알고 있습니다.

우리가하려는 것은 진정한 스칼라와 벡터를 갖도록 일관된 방식으로 순수 매트릭스 설정을 확장하고 정제하는 것이며, 일관성, 코 벡터를 위해 필요하기 때문이라고 생각합니다.

다음은 스칼라와 벡터에 대한 내 관점입니다 (순수 행렬 관점에서 볼 때) : 스칼라는 행렬이며, 유형에 따라 1 x 1로 제한됩니다. 벡터는 행렬이며, 유형에 따라 (아래에서 covector는 유형에 따라 1 x n으로 제한되는 행렬이라고 주장 할 것입니다.)이 관점에서 우리는 두 가지 공리를 제공 할 수 있습니다. (아래에서 매우 공식적으로 설명하지 않음)

• 확장 : 행렬에서 행렬로의 함수를 고려하십시오. 특정 유형의 입력이 주어지면 주어진 차원에서 크기가 1 인 출력 행렬을 항상 생성하는 경우 해당 사실은 출력 유형으로 인코딩됩니다 (스칼라 / 벡터 / 코 벡터가 됨).
• 구체화 : 순수 행렬 설정에서 행렬 인수를 사용하는 함수가 입력이 하나 이상의 차원에서 1 크기를 가져야하는 경우이 사실이 유형으로 인코딩되지 않은 입력을 거부 할 수 있습니다.

위의 내용에 동의하면 벡터의 전치가 위에 설명 된 코 벡터 유형이어야합니다. anx 1 행렬의 전치는 1 xn 행렬을 생성합니다. 결과의 첫 번째 차원에 따른 크기가 항상 1이라는 사실을 인코딩하면 위에서 설명한대로 코 벡터를 얻습니다.

행렬 대수 관점에서 시작하면 말이 맞습니다. 이것은 MATlab이 아마도 완벽하게 구현 한 모델입니다. 모든 것이 매트릭스입니다. 그것은 폐쇄 된 시스템이며, 행렬에 대한 모든 연산은 새로운 행렬을 생성합니다.

나는 확실히이 문제의 요점 (벡터가 단순히 행렬이 아니기 때문에 심각하게 전치하는 벡터를 취하는 것)은 그 행렬 대수 모델에서 벗어나는 것이라는 인상을 받았습니다. 이유 때문에 1x1 행렬에서 숫자를 분리하려는 경우 불일치를 보이기 시작하기 때문입니다. 효율성. 그런 다음 대안은 선형 대수 모델을 따르는 것입니다. 여기서 필드 (스칼라), 벡터 공간 (및 해당 이중), 선형 연산자 / 변환 공간 (행렬) 사이에 분명한 차이가 있습니다.

줄리아의 선형 대수 연산은 스칼라와 벡터가 있고 사용자를 추측하지 않는 것과 같은 몇 가지 주목할만한 예외를 제외하고는 MATLAB 전통에 상당히 뿌리를두고 있다고 생각합니다. 그것에서 너무 멀어지는 것은 매우 큰 혼란 일 수 있습니다.

위의 공리는 효율성과 정확성을 위해 행렬에서 스칼라와 벡터를 분리하려고 할 때 나타나는 불일치를 해결하기 위해 진행되어야한다고 생각합니다. 그러나 나는 다른 가능한 시스템에 대해 확실히 듣고 있습니다.

여기에서 @Jutho에 동의합니다. 이 문제의 요점은 MATLAB의 "모든 것이 행렬입니다"라는 의미에서 벗어나는 것입니다. MATLAB의 "후행 단일 차원을 추가 할 수 있음"규칙은 선형 대수 연산에서 유니버스를 닫는 데 필요하지만이 규칙은 T 유형의 멤버와 Array{T,N} 유형의 다른 멤버를 포함하는 동등 클래스를 정의합니다. 모두 N 이며 MATLAB의 유형 시스템을 결정할 수없는 주된 이유입니다. ( Joisha and Banerjee, 2006 의 Theorem 1 참조-결과가 모양으로 명시되어 있지만 문제는 실제로 배열 순위를 변경하면 프로그램 의미를 어떻게 바꿀 수 있는지에 관한 것입니다.)

하지만 저는 여전히 스칼라, 벡터, 코 벡터, 행렬의 곱셈이 연관되어야한다는 것에 대해 꽤 좋은 합의를 이루었다 고 생각합니다 ( (v'*v)*v 와 같은 경우는 예외입니다. 여기서 두 개의 비 스칼라가 곱하여 스칼라를 생성합니다). 예를 들어 v'*M*v 는 스칼라, M*v 벡터 및 v'*M 벡터를 생성해야합니다. 이러한 조건을 충족하면서 모든 것이 매트릭스라는 의미에서 얼마나 멀리 벗어날 수 있는지 잘 모르겠습니다.
우리가 피하려는 것이 더 무엇이며 대신 어떤 속성을 얻고 싶습니까?

경우에 따라 T 와 Array{T,0} 만 합치면 얼마나 더 나빠질까요? (예 : 인덱싱 : M[:,2] 는 Array{T,1} 를 생성하지만 M[2,2] 는 Array{T,0} 생성하지 않습니다.)

우리는 Transpose{Vector} 여전히 유효한 의미를 유지할 수 있습니다.

나는 연관성에 대한 모든 의견을 다시 읽었고 그 토론의 대부분은 실제로 연관성 자체가 아니라 내부 제품과 외부 제품의 의미론에 관한 것이라고 결론지었습니다. 둘 중 하나에 해당하지 않는 표현을 찾으면 지적하십시오.

Matlab 유형 의미 체계의 문제점은 M*v' 및 v*M 가 작동하지 않아도 작동하는 경우가 있다는 것입니다. M 이 m x 1 이면 M*v' 가 유효하고 외부 제품과 유사한 수량을 반환합니다 ( v' 는 1 x n 이므로). 마찬가지로 M 가 1 x m 이고 "can add trailing singletons"규칙이있는 경우 v*M 는 n x 1 및 1 x m 의 곱으로 평가 될 수 있습니다

T 와 Array{T,0} 의 결합 문제는 APL 문헌에서도 제기되었습니다. APL에서 다차원 배열은 재귀 적으로 중첩되어 Array{T,0} 및 T 여부에 대한 질문을 제기합니다. T 까지 반복됨), 그렇지 않으면 "부동 배열"( Array{T,0} 까지만 반복됨)입니다. 나는 More, 1973이 실제로 두 선택이 공리적으로 일관성이 있음을 증명했다고 믿습니다. 나는 APL이 대부분의 실무자가 은퇴하거나 다른 것으로 이동하기 전에 사용할 질문을 해결했는지 확실하지 않습니다.

@jiahao : 당신의 관찰이 얼마나 근본적인지

v[i] = e_i' * v

선형 대수와 인덱싱 의미를 함께 연결합니다. 그러나 당신은 또한 고려해야합니다

M[i,j] = e_i' * M * e_j

이는 오른쪽에서 기저 벡터가있는 내적이 두 번째 차원의 인덱싱에 해당함을 나타냅니다. 따라서 코 벡터 v' 의 i 번째 항목은 다음과 같이 인덱싱되어야합니다.

v' * e_i = v'[1, i]

물론 첫 번째 색인으로 1 이외의 것을 작성하고 싶은 곳은 어디입니까?
어쨌든, 우리는 허용하기 때문에

e_i' * v = v[i] = v[i, 1]

위의 경우에도 1 를 자리 표시 자로 허용해야합니다.

v' * e_i 는 스칼라이므로 e_1' * (v' * e_i) 는 스칼라가 아니라 코 벡터입니다. 따라서 v'[1, i] = e_1' * v' * e_i 를 생각할 때 치수가 일치하지 않습니다.

편집 : 이것이 인덱싱에서 후행 싱글 톤을 허용하는 것에 대한 논쟁 일 수 있다고 생각합니까?

예, 행렬 인덱싱은 다음 논리적 단계이며 e_i' * M * e_j 는 실제로 연관성 공리가 유용한 표현식 중 하나입니다.

(e_i' * M) * e_j = m_i' * e_j

e_i' * (M * e_j) = e_i' * m_j

동일해야합니다. 행렬 인덱싱은 벡터 인덱싱 규칙과 코 벡터 인덱싱 규칙에서 파생 될 수 있습니다.

이 인덱싱 동작을 허용하는 규칙 때문에이 문제를 일관되게 해결하려면 v[i, 1] 와 같은 식을 허용하지 않아야 할 수 있습니다.
a) A*v' 및 v*A 에 대한 가짜 케이스가 작동하도록해야합니다 (전자는 작동하지만 후자는 후행 싱글 톤 규칙을 일관성없이 적용하기 때문에 작동하지 않음).
b) v[i] = v[i, 1, 1, 1] 의 동등성을 고려한다면, 상응하는 코 벡터 인덱싱 규칙은 (v')[1, 1, 1, i] 처럼 보일 것이고 일관성을 위해 코 벡터에 대해 상응하는 "임의의 선행 싱글 톤 허용"규칙을 가져야합니다. 나는 독특하게 정의 된 1 차원의 부족이 매우 혼란 스럽다는 것을 안다.

나는이 색인 추론이 실제로 아무데도 가지 않는다고 생각한다. 인덱싱은 N 차원 배열의 일반적인 속성이며 N=1 또는 N=2 대한 간단한 행렬 식으로 작성할 수 있다는 점은 다소 사소하고 기본적인 요소를 포함하지 않습니다. 정보. 그러나 이것은 더 높은 순위의 배열로 일반화되지 않으므로 인덱싱 할 때 covector가 선행 1이 필요한지 여부를 결정하는 데 사용해서는 안됩니다. 이로 인해 이전 게시물에서 볼 수 있듯이 불일치가 빠르게 발생합니다.

위에서 언급했듯이, 나는 하나의 인덱스에 의존하는 팬이 아니었고 그것이 필요하거나 실제로 유용한 단일 상황을 생각할 수 없었습니다. 그러나 나는 내 관점이 너무 제한적이라는 것을 받아 들일 수 있습니다.

나는이 모든 것을 완전히 소화하지는 못했지만 내 주요 질문은 단순히 size(covector) 가 (n,) 같거나 (1,n) 같습니까?

AbstractArray 패밀리의 일부가 아닌 경우 size 를 정의 할 필요도 없습니다.

실용적인 이유로 나는 그것이 정의 될 것이라고 생각하지만 (숫자 등) 내 투표는 (n,) 합니다. 저장 / 컨테이너 관점에서 벡터와 코 벡터 사이에는 구별이 없다고 말하고 싶습니다. 따라서 코 벡터를 컨테이너로 사용할 필요가 없으므로 AbstractArray 계층 구조에 속하지 않습니다. 선형 대수 연산과 관련하여 벡터와 다르게 동작한다는 것을 표현하는 것은 단순한 래퍼 유형입니다.

"대수학과 기하학이 분리되어있는 한, 그들의 발전은 느리고 그 용도는 제한적이었습니다. 그러나이 두 과학이 통합되었을 때 그들은 각각의 상호 힘을 빌려주고 완벽을 향해 함께 행진했습니다." -조셉 루이스 라그랑주

더 많이 기여할 수 있으면 좋겠지 만 물리학 자와 엔지니어가 사용하는 정교한 수학적 도구를 사용하기 쉽고 정확하도록 만드는 시스템을 선호한다고 생각했습니다. 아마도 MIT의이 리소스가 유용 할 수 있습니다 ...

http://ocw.mit.edu/resources/res-8-001-applied-geometric-algebra-spring-2009/lecture-notes-contents/

사실 생각해 보면 더 공평하다고

e_i' * x = x[i, :] # x is a vector or matrix
x * e_j  = x[:, j] # x is a covector or matrix

그런 다음 매트릭스 인덱싱을 위해 우리는

e_i' * M * e_j = e_i' * (M * e_j) = e_i' * M[:, j] = M[:, j][i, :] = M[i, j]
e_i' * M * e_j = (e_i' * M) * e_j = M[i, :] * e_j  = M[i, :][:, j] = M[i, j]

현재 이것은 줄리아에서 잘 유지되지 않습니다. 예를 들어 v[i, :] 현재 스칼라가 아닌 1x1 배열을 생성합니다. (하지만 안 될 수도 있습니다)
e_i' * M * e_j 에서 행렬 곱셈의 연관성은 다른 차원 M[:, j][i, :] = M[i, :][:, j] 따라 자르는 commutativity에 해당하며, 이는 바람직한 기능처럼 보입니다.
위의 reasoing 라인에 의해 우리는

v'[:,i] = conj(v[i])

@Jutho :이 "반복 된 슬라이스로 인덱싱"패러다임이 더 높은 차원의 배열 / 텐서에 일반화한다고 생각합니다. 인덱스에 각 차원에 대해 하나의 슬라이싱을 순서에 관계없이 적용합니다. 이것은 e_i 등에 해당하는 1 차 텐서가있는 일련의 수축에 해당하며, 어떤 순서로도 일치합니다 (어떤 차원이 일치하는지 추적하는 한).

이 "반복 된 슬라이스로 인덱싱"패러다임이 더 높은 차원의 배열 / 텐서에 일반화한다고 생각합니다. 인덱스에 각 차원에 대해 하나의 슬라이싱을 순서에 관계없이 적용합니다. 이것은 e_i 등에 해당하는 1 차 텐서를 가진 일련의 수축에 해당하며, 어떤 순서로도 일치합니다 (어떤 차원이 일치하는지 추적하는 한).

예 저는 텐서 수축 등에 매우 익숙하며 실제로 행렬 요소 / 텐서 요소를 얻는 것은 표준 계산 기반에서 기대 값을 취하는 것과 일치합니다. 즉, 일부 기저 벡터로 축소하는 것과 같습니다 (최소한 직교 기저가있는 한 ), 그러나 인덱스가 e_i 또는 e_i' 와의 축소에 해당하는지 여부에 대한 고유 한 연관성은 없습니다. 이는 해당 인덱스가 공변 또는 반 변성 위치에 나타나는지 여부를 결정하는 것에 해당하며 고유 한 결정이 없습니다. 상위 및 하위 인덱스의 가능한 모든 조합에는 유용한 응용 프로그램이 있습니다. 그러나 e_i 및 e_i' 와 계약하는 것은 수학적 관점에서이 질문을 제기하는 올바른 방법조차 아닙니다. 제가 위에서 언급했듯이 실제로 다음과 같은 수학적 매핑은 없습니다. 벡터의 전치. 전치는 선형 맵 (행렬)에 대해 정의 된 연산이며 이중 벡터를 열 벡터로 쓰는 경우에도 행렬 전치에만 해당합니다. 벡터의 전치 (transpose)는 행렬 대수 (실제로 벡터가 n x 1 행렬 인 경우)에 도입 된 편리한 트릭이며 (conjugate에서 정규 매핑이있는 유클리드 공간에 있기 때문에 작동합니다. ) 벡터 공간을 이중 공간으로.

특히 위에서 설명한 속성을 원하면 M[i,:] 가 다른 객체 ( 1xn 행렬 또는 코 벡터)를 반환 한 다음 M[:,i] ( nx1 행렬 또는 벡터). 이것이 더 높은 차원으로 명확하게 일반화되지 않는다는 사실은 정확히이 문제의 주요 논의 사항 중 하나이며, 대부분의 사람들은 숫자로 인덱스 된 차원이 삭제되는 APL 인덱싱을 선호하는 것 같습니다 (예 : 둘 다 M[:,i] 및 M[i,:] 는 순위 1 배열을 생성하므로 벡터가됩니다. 인덱싱은 배열의 속성이며 인덱싱 동작과 선형 대수 연산이 혼합되어 처음에 모든 혼란 / 불일치를 초래합니다. N=2 등급 객체의 폐쇄 된 생태계 내에 머무르는 한 일관성이있을 수 있습니다. 즉, 모든 것이 행렬이며 벡터와 숫자이며 더 높은 차원의 배열은 고려하지 않습니다.

나는 또한 당신이 말했듯이 위의 추론에 의해 M[i,:] 이 코 벡터를 생성해야한다는 것을 깨달았습니다. 따라서 covector를 갖는 것은 APL 인덱싱과 근본적으로 일치하지 않는 수준입니다. 우리가 APL 인덱싱을 선호한다면 (그리고 나는 그것을 좋아합니다) 그 세계와 코 벡터가 사는 세계 사이에 선을 그릴 위치가 문제가됩니다. (나는 둘을 화해시킬 수 있기를 바랬는데, 아마도 나머지는 우리가 그것을 포기해야한다는 것을 이미 깨달았을 것입니까?)

이 갈등은 당신이 그것에 대해 생각한다면 그리 놀라운 일이 아닐 것입니다.

• APL 인덱싱에서는 의미 있고 인덱싱 가능한 차원 만 결과에 유지됩니다. 나머지는 압착됩니다.
• v' 로 그렇게한다면 v' = conj(v) 갖게됩니다. 대신 코 벡터는 누락 된 1 차원을 추적하는 것으로 볼 수 있습니다.

기본적으로 곱셈, 더하기 / 빼기 및 왼쪽 나눗셈을 정의하여 가능한 한 많이 코 벡터를 제한하는 것이 좋은 시작이라고 생각합니다.

아이디어는 그들을 <: AbstractArray 만들지 않는 것 같습니다. 새로운 LinearOperator 유형의 하위 유형이되는 것이 합리적일까요? (내가 아는 것은 이전에 논의가 있었지만 결론을 잘 기억하지 못합니다.)

다중 상속이 없거나 인터페이스에 대한 언어 구성 (둘 다 논의 중임)은 특정 개념이 '암시 적'인터페이스, 즉 정의해야하는 메서드 집합에 의해서만 구현되어야한다고 생각합니다. 반복자는 이러한 개념 중 하나이며 선형 연산자는 유형 계층 구조가 아닌 메서드 집합에 의해 지정되어야하는 또 다른 개념 일 것입니다. 추상 유형이 LinearOperator 이고 그 하위 유형이 될 Matrix 가없는 것은 이상 할 것입니다.

@toivoh 이것은 중요한 고려 사항입니다. 이것이 제가 row(M,i) 및 col(M,i) 와 같은 새로운 함수를 제안하여 행렬에서 i 번째 벡터 또는 코 벡터를 추출하는 이유입니다. 이 함수는 2 차원 배열 M 및 행렬 대수에 관심이있는 사람들을위한 것입니다. 처음에는 MATLAB 스타일 인덱싱보다 약간 덜 명확 해 보일 수 있지만 전반적으로 벡터의 개념을 개념적으로 분리하고 이중 / 전치 / 코 벡터를 사용하면 상황을 명확하게하는 데 도움이됩니다. 양자 역학의 경우, 벡터와 코 벡터 간의 이러한 구별이 복잡한 벡터에 매우 중요하기 때문에 전체 필드가 ​​Dirac의 브라켓 표기법으로 뛰어 올랐으며 Dirac의 표기법이이를 명백하게 만듭니다. Julia가이 작업을 수행 할뿐만 아니라 고차원 저장 배열 및 고차원 선형 대수를위한 좋은 도구가되기를 바랍니다. (우리가 욕심 이니까?)

MATLAB에 대한 경험이 있고 대부분 실제 행렬에 익숙한 사람 (하드 코어 선형 대수 광신자는 아님)이 우리 중 소수가 주장하는 것이 왜 중요한지 처음에는 깨닫지 못할 수도 있지만 저는 믿으세요.

앞서 말씀 드렸지만 반복하겠습니다. 내 관점에서 우리는 우선 순위 목록을 가지고 있으며 인과 관계는 아래로 내려갑니다.

(1) 배열은 기본적으로 모든 Julia 사용자가 사용할 저장소 컨테이너이며이를위한 최상의 의미 체계를 원합니다. 어쨌든 APL 스타일의 규칙은 저에게 아주 좋은 해결책 인 것 같습니다. 반면에, 후행 1 차원 인덱스가있는 가정이있는 MATLAB 스타일의 최소 2 차원 배열은 부자연스럽고 혼란스러워 보이며 Jutho가 말했듯이 올바르게 추적하지 않는 경우 엉성한 프로그래밍으로 이어질 수도 있습니다. 배열의 차원. 지금까지 v 벡터의 경우 v 가 1 차원이므로 v[i,:] 코드에서 오류가 발생해야합니다. + 및 .* 와 같은 요소 별 연산은 행렬 또는 다중 선형 대수뿐만 아니라 모든 컨테이너 클래스에 유용합니다. 아래 항목에 대해 사람들이 만드는 유일한 양보 저장소 컨테이너는 .* 등의 추가 점입니다.

(2) 전부는 아니지만 대부분의 Julia 사용자는 행렬 대수를 사용하므로 대부분 * 기호를 사용하여 일부 벡터 및 행렬 연산에 대한 구문 설탕을 추가합니다 (그러나 행렬 분할 등이있을 수 있음). 이 시스템에서는 1 차원 배열과 2 차원 배열을 각각 열 벡터와 행렬로 사용합니다. 완전히 기능하는 행렬 시스템의 경우 행 벡터 (코 벡터)와 전치 연산 ' 합니다. 행 벡터는 가능한 모든 의미에서 1 차원 배열이며, 그 자체로 인덱싱되어야한다고 주장합니다 (확실히 covec[1,i] !!) APL 규칙을 사용하면 일부를 만들 수 있습니다. 벡터와 covectors 및 형식 시스템 사이의 차이는 우리가 할 수 원칙적으로 ...이 이상적이 (우리는 우리가 이미 오히려 래퍼 형 이상 및 2 차원 배열의 typealiases 같은 행렬 및 벡터를 재사용 할 수 있다는 운이 기억입니다 그것들도 포장하지만 요점은 보이지 않습니다). 타입 시스템을 사용하면 컴파일러는 CoVector * Vector 가 스칼라이고 Vector * CoVector 가 행렬임을 알아낼 수 있습니다. toivoh가 말했듯이 _MATLAB 관점에서 CoVector는 "누락 된"첫 번째 차원을 정확히 추적합니다 ._ 일반 사용자는 이러한 객체를 구성 할 필요가 없습니다. 벡터와 행렬을 입력하고 * 및 ' 연산을 사용합니다. 관심있는 사람들은 그 차이를 알아 차리고 감사 할 것입니다. 사용자에게 가장 큰 변화는 M[i,:] 를 새 함수 row(M,i) 하거나 Transpose(M[i,:]) 또는 M[i,:]' 와 같은 래퍼 클래스로 변환해야한다는 것입니다. Dirac 표기법처럼 어떤 객체가 벡터인지 코 벡터인지 절대 잊지

(3) 우리 중 일부는 다중 선형 대수에 관심이 있고 이중 공간과 전치 등의 차이를 배워야했습니다. Jutho가 이에 대해 언급했습니다. Julia의 배열은 이미 더 높은 차원의 텐서를위한 훌륭한 저장 장치이며, 우리와 같은 사람들은 추가 패키지 (Base로 갈 수도 있고 없을 수도 있음)를 사용할 것입니다. 2보다 큰 차원 배열에 정의 된 ' 또는 * 와 같은 연산이 필요하지도, 원하지도 않습니다. 인덱스를 명시 적으로 재정렬하여 더 깔끔하게 수행 할 수없는 ' 대한 스토리지 지향 사용 사례를 볼 수 없습니다. 후행 1 차원 인덱스에 대한 전체 아이디어는 개념을 덜 매력적으로 만듭니다. 따라서 MATLAB과 같이 1 차원 및 2 차원 배열에만 ' 을 유지하십시오. MATLAB에 대해 이야기하십시오 ...)

완전히 기능하는 행렬 시스템의 경우 행 벡터 (코 벡터)와 전치 연산 '도 필요합니다.

이 진술은 실제로 문제의 핵심을 잘라냅니다. 인덱싱, 조옮김 및 * 제품은 모두 혼합되어 있습니다. 또한, 상기와 같은 기능을 도입하지 않고 covectors의 것과 행 벡터의 모든 의미를 조정하는 것은 불가능 row(A, i) 복귀하도록 i 의 행째를 A A와 1 차원 배열이 아닌 covector. 현재 A[1, :] 는 "A의 첫 번째 행 가져 오기"와 "A의 두 번째 차원을 따라 첫 번째 슬라이스 가져 오기"를 모두 의미하지만 이러한 개념은 기본적으로 코 벡터 제안에서 호환되지 않습니다.

행 벡터는 가능한 모든 의미에서 1 차원 배열이며, 이와 같이 인덱싱되어야한다고 주장합니다.

나는 당신이이 성명서에 너무 냉담하다고 믿습니다. 앞의 논의는 완전한 선형 대수 의미론 (올바른 곱 및 전치 포함)을 원한다면 행 벡터가 1 차원 배열과 동일한 유형을 가질 수 없다는 것을 매우 명확하게 설정했습니다. 첫째, covector에 대한 인덱싱은 내적 dot 와의 일관성을 위해 복잡한 켤레 값 (v')[1] = conj(v[1]) 반환해야합니다. 둘째, 코 벡터는 벡터가 아니며 벡터로 내적을 생성하기 위해 대기하는 선형 함수입니다. 셋째, 벡터와 코 벡터는 hcat 및 vcat 아래에서 배열 연결 동작이 다릅니다. 이러한 모든 이유로 행 벡터는 "가능한 모든 의미에서 1 차원 배열"이 될 수 없습니다.

나는 후행 싱글 톤을 제거하는 편에 찬성 할 것이다. 나는 그것을 사용하는 Julia 코드를 본 적이 없다고 생각한다. 원래 0 차원 배열에 필요하다고 말하려고했지만 X[] 가 잘 작동한다는 것을 알았습니다.

행 벡터에 대한 row(M,i) 함수와 함께 APL 인덱싱이 가장 합리적이며 좋은 절충안처럼 보입니다. 행 벡터 인덱싱에 대해 잘 모르겠지만 (v')[1,i] 좋아하지 않습니다.

우리가 아직 다루지 않은 또 다른 큰 결정은 유형입니다. 이전에 이것을 시도한 내 한 가지 발견은 디스패치를 ​​엉망으로 만들기 때문에 v' 를 AbstractVector 시키는 것이 정말 어렵다는 것입니다.

두 가지 가능한 옵션 :

1. 행렬과 벡터에 대해 별도의 유형을 사용합니다.
   
   
   
   • Transpose <: AbstractMatrix
   
   
   • CoVector <: Any
   
   
   • Factorization 객체에 대한 일종의 전치.
   
   
2. 모든 전치에 동일한 유형을 사용하지만 X' _not_은 AbstractMatrix
   
   
   
   • Transpose <: Any
   
   

활용을 위해 우리는

ㅏ. ConjugateTranspose 정의 (위의 옵션 1을 사용하는 경우 ConjugateCoVector 와 함께)

비. Conjugate 래퍼 유형을 사용하고 적절하게 중첩합니다. Transpose{Conjugate{T}} 또는 Conjugate{Transpose{T}} 사용 여부에 대한 규칙이 필요합니다.

AbstractMatrix 의 하위 유형이 아닌 Transpose{Matrix} 를) 갖는 것이 좋습니다. 우리가베이스에서 가장 가까운 아날로그는 Symmetric 와 같은 특별한 행렬 유형이라고 생각합니다. 이것은 대수적으로 행렬처럼 작동하지만 색인 의미론에서는 작동하지 않습니다. (# 987은 다중 내재 또는 신성 특성없이 유형 계층 구조가 대수적 의미론보다 컨테이너 의미론을 존중해야한다는 것을 확립했습니다.)

기본적으로 "의미 적 태그"인 유형을 구성하는 문제도 # 8240에서 나타났습니다. 나는 Transpose{Conjugate{T}} 가 더 낫다고 생각합니다. 왜냐하면 활용은 요소의 기본 필드에 해당하는 개념이기 때문입니다.

다음은 때때로 MATLAB과 동일한 후행 싱글 톤 규칙을 따르고 다른 경우에는 따르지 않는 예입니다.

• 인덱싱 작업에서 후행 싱글 톤이 허용됩니다. (MATLAB처럼)

julia> (1:5)[5,1,1,1,1,1,1]
5

• 인덱싱 작업에서는 후행 조각이 허용되지 않습니다. (이를 허용하는 MATLAB과는 다릅니다.)

julia> (1:5)[5,:]
ERROR: BoundsError()
 in getindex at abstractarray.jl:451

• 순위> = 3 배열의 경우 배열의 순위보다 더 적은 인덱스가 있고 마지막 인덱스가 스칼라 (예 : MATLAB)이면 암시 적 후행 싱글 톤이 인덱스 할당 연산에 추가됩니다.

julia> A=zeros(2,2,2); A[1,2]=5; A #Same as A[1,2,1]=5
2x2x2 Array{Float64,3}:
[:, :, 1] =
 0.0  5.0
 0.0  0.0

[:, :, 2] =
 0.0  0.0
 0.0  0.0

• 순위> = 3 배열의 경우, 배열 순위보다 더 적은 인덱스가 있고 마지막 인덱스가 _not scalar_ (MATLAB처럼) 일 때 암시 적 후행 _slices_가 인덱스 할당 연산에 추가됩니다.

julia> A[:,:]=3; A
2x2x2 Array{Float64,3}:
[:, :, 1] =
 3.0  3.0
 3.0  3.0

[:, :, 2] =
 3.0  3.0
 3.0  3.0

• 순위> = 3 배열의 경우 배열의 순위보다 적은 인덱스가 있고 마지막 인덱스가 스칼라 (예 : MATLAB)이면 암시 적 후행 싱글 톤이 인덱싱 작업에 추가됩니다.

julia> A=reshape(1:8,2,2,2); A[:,1]
2-element Array{Int64,1}:
 1
 2

julia> A[:,1,1]
2-element Array{Int64,1}:
 1
 2

• 순위 r> = 3 배열의 경우 배열의 순위보다 k <r 인덱스가 있고 마지막 인덱스가 슬라이스 인 경우 인덱싱 작업은 나머지 순위 rk 배열을 암시 적으로 선형화합니다. (MATLAB과 유사) :

julia> A=reshape(1:8,2,2,2); A[1,:]
1x4 Array{Int64,2}:
 1  3  5  7

julia> A=reshape(1:8,2,2,2); A[1,:,:]
1x2x2 Array{Int64,3}:
[:, :, 1] =
 1  3

[:, :, 2] =
 5  7

• 후행 싱글 톤은 할당 작업에서 삭제되지 않습니다. (MATLAB과 달리)

julia> A=zeros(1); A[1] = randn(1,1)
ERROR: `convert` has no method matching convert(::Type{Float64}, ::Array{Float64,2})

You might have used a 2d row vector where a 1d column vector was required.
Note the difference between 1d column vector [1,2,3] and 2d row vector [1 2 3].
You can convert to a column vector with the vec() function.
 in setindex! at array.jl:307

julia> A=zeros(1,1); A[1,1] = randn(1)
ERROR: `convert` has no method matching convert(::Type{Float64}, ::Array{Float64,1})
 in setindex! at array.jl:308

• Julia는 유효한 작업을 허용 할 때 후행 단일 치수를 자동으로 추가하지 않습니다. (매트랩과 달리)

julia> 1/[1.0,] #In MATLAB, interpreted as the inverse of a 1x1 matrix
ERROR: `/` has no method matching /(::Int64, ::Array{Float64,1})

• 외부 제품은 작동하며 이전 규칙의 예외입니다. 그들의 의미는 암시 적으로 첫 번째 인수에서 후행 싱글 톤을 사용합니다. (Matlab처럼)

julia> [1:5]*[1:5]' # Shapes are (5,) and (1,5) - promoting to (5,1) x (1,5) works
5x5 Array{Int64,2}:
 1   2   3   4   5
 2   4   6   8  10
 3   6   9  12  15
 4   8  12  16  20
 5  10  15  20  25

우리가 그것들이 어떻게 행동하기를 바라는지 결론을 내리면 이러한 것들은 약간의 정리가 필요할 것 같습니다. 마지막 인덱스가 슬라이스 인 인덱스가 너무 적은 인덱스를 만들 때 현재 동작은 특히 비린내처럼 보입니다.

와. Jiahao가 제시 한 예는 매우 혼란 스럽습니다 ... 저는 인덱싱 작업과 인덱싱 할당 작업에서 후행 싱글 톤이 묵시적이고 모호하기 때문에 싫어합니다. 이러한 행동을 미리 알지 못한다면 실제로 다른 일을하려고 할 때 한 가지 일을하게 될 수 있습니다. 나는 언어를 정확하고 명확하게 사용하고 모호한 단축키를 피하는 것을 선호합니다.

이를 실제로 구현하려면 일종의 삼각형 디스패치가 필요합니다. 그렇지 않으면 " Complex64 또는 Complex128 항목이있는 행렬, 전치 , 또는 그것의 켤레 전치 ". 특히 위의 옵션 2 + b를 사용하는 경우.

@ esd100 , 이들 중 모호하거나 위험한 것은 무엇입니까? 이것들은 모두 편리합니다. "가상 싱글 톤"이 당신을 위해 상상되고 당신이 원할 때-또는 당신이 원하고 원하지 않았을 때-불편할 때-입니다. 이들 중 어떤 것도 행동이 다른 두 가지 그럴듯한 의미를 가지고 있지 않습니다.

행 벡터는 가능한 모든 의미에서 1 차원 배열이며, 이와 같이 인덱싱되어야한다고 주장합니다.

나는 당신이이 성명서에 너무 냉담하다고 믿습니다.

진실! 죄송합니다 @jiahao , 시차를 비난하겠습니다. 제가 쓰려고했던 단어는 "tensor"이고, 저는 [] 인덱싱 동작을 엄격하게 언급했습니다. 연결이 중요한 고려 사항이라는 것이 맞으며, (행렬을 구성하는) 자연스러운 방법은 (이 경우 1 xn 크기로 생각하면) 합리적으로 분명하다고 생각합니다. 분명히 covector는 "모든 의미에서"1D Julia Array가 아닙니다. 그게 전체 요점입니다 ...

jiahao의 예도 저를 방해합니다. 가능한 후행 싱글 톤 동작을 제거하는 것이 좋습니다. 나중의 차원을 선형화하는 것이 유용 할 수 있지만 배열이 얼마나 많은 차원을 가지고 있는지 잊어 버리는 일종의 게으름을 조장 할 수 있습니다. (나는 이것이 "모호함"과 "위험한"이 암시하는 것이라고 생각합니다 ... 정말 원합니다 예를 들어 16 차원 배열을 15 차원 배열처럼 취급 할 때 Julia가 오류를 던집니다.

이들 중 모호하거나 위험한 것은 무엇입니까?

네 번째는 모호하고 위험 해 보입니다.

julia> A=zeros(2,2,2); A[:,:]=3; A
2x2x2 Array{Float64,3}:
[:, :, 1] =
 3.0  3.0
 3.0  3.0

[:, :, 2] =
 3.0  3.0
 3.0  3.0

분명히 (나에게) 이것은 구문 오류 여야합니다. A는 랭크 -3이고 3 차원은 전혀 참조되지 않았습니다. 세 번째 차원은 오류로 인해 중단되었을 가능성이 높으며 이제 찾기 어려운 버그가 코드에 도입되었습니다. (IDL과 포트란 모두에서와 같이) 그의 시점에서 오류가 발생하면 감사합니다.

배열이 올바른 수의 인덱스로만 인덱싱을 허용하거나 1D 선형 인덱싱의 특수한 경우 (매우 편리하기 때문에)가 가장 좋다고 생각합니다. 여기에는 후행 싱글 톤을 허용하지 않는 것도 포함됩니다.

또는 1D 선형 인덱싱의 특별한 경우 (매우 편리하기 때문에)

우리 원칙이 얼마나 쉽게 팔리는가! :)

선형 인덱싱을 그다지 좋아하지 않았습니다. 그것은 나에게 약간의 해킹이라고 생각합니다. 종종 우리는 배열을 반복하는 가장 빠른 방법을 원합니다. 그리고 단순한 조밀 한 배열을 제외한 모든 선형 인덱싱은 정말 느릴 수 있습니다. 즉, 선형 인덱싱을 완전히 제거하지 못할 수도 있습니다 (성능상의 이유와 너무 많은 코드를 손상시키기 위해).

네, 사실입니다. 그러나 적어도 1D 인덱싱은 시각적으로 구별됩니다. 5D로 6D 배열을 인덱싱하는 것은 훨씬 적습니다. 어쨌든 나는 더 엄격한 인덱싱 규칙을 갖고 다른 방향으로가는 것보다 1D 선형 인덱싱을 포기할 것입니다. 특히 메모리를 공유하는 배열에 대한 재구성 된 참조를 쉽게 얻을 수 있기 때문입니다.

선형 인덱싱에 {} 대괄호 (또는 기타)를 사용하고 다차원 인덱싱에 [] 을 유지할 수 있습니까? 그냥 아이디어 ...

2015 년 3 월 23 일 2:36 pm에 Bob Portmann [email protected] 은 다음과 같이 썼습니다.

네, 사실입니다. 그러나 적어도 1D 인덱싱은 시각적으로 구별됩니다. 5D로 6D 배열을 인덱싱하는 것은 훨씬 적습니다. 어쨌든 나는 더 엄격한 인덱싱 규칙을 갖고 다른 방향으로가는 것보다 1D 선형 인덱싱을 포기할 것입니다. 특히 메모리를 공유하는 배열에 대한 재구성 된 참조를 쉽게 얻을 수 있기 때문입니다.

—
이 이메일에 직접 답장하거나 GitHub https://github.com/JuliaLang/julia/issues/4774#issuecomment -84805310에서

구문을 분리 할 수 ​​있었으면 좋겠다고 생각합니다.
일반 인덱싱 구문에서 선형 인덱싱을 수행하지만 동의합니다.
엄청난 변화 일 수 있습니다.

이 문제는 많은 논쟁을 불러 일으키는 것처럼 보이지만 인덱싱 개선을위한 실제 작업의 대부분은 0.4주기 동안 상당히 많은 수의 pull 요청에서 발생했습니다. 예를 들어, 이제 CartesianIndex 와 친구가 있으므로 선형 및 데카르트 인덱싱을 위해 구문을 분리해야하는 이유를 알 수 없습니다. 실제로 이들을 결합 할 수 있습니다 (# 10524). 선형 인덱싱도 제거하고 싶지만 때로는 더 성능이 좋습니다 (아마도 # 9080; enumerate 및 zip 때문에 동일한 문제가 발생합니다). # 10507에서와 같이 fastindex 를 eachindex 주위의 래퍼로 구현해야합니다.

색인 규칙에 관심이 있다면이 문제를 죽이는 대신 가장 흥미로운 영역에 초점을 맞추겠습니다. 현재로서는 의심 할 여지없이 # 10525입니다. 특히 https://github.com/JuliaLang/julia/pull/10525#issuecomment -84597488에는 일종의 해결 방법이 필요합니다.

@timholy 저는 빠른 데카르트 인덱싱에 대한 모든 개발을 실제로 따르지 않았으며 base / multidimensional.jl을 방금 살펴

어떤면에서 알아야 할 것이 많지 않습니다. 내부적으로 상당한 양이 진행되고 있지만, 아이디어는 사용하기 더럽게 만드는 것입니다. 그래서 말 그대로

k = 0
for I in eachindex(A)
     B[k+=1] = A[I]   # B is being linearly-indexed, A is being cartesian-indexed
end

당신이 알아야 할 전부일 수도 있습니다. (즉, eachindex 대한 도움말이 필요한 모든 문서 일 수 있습니다.) 그러나이 기본 패러다임의 몇 가지 확장을 사용하여 상당히 많은 알고리즘을 작성할 수 있음이 밝혀졌습니다. 이러한 확장이 무엇이며 왜 강력한 지 명확하지 않을 수 있습니다.

나는 앞으로 몇 달 안에 이것을 적을 계획이지만 사람들이 정말로 세부 사항을 알고 싶다면 JuliaCon 토크가 합리적 일 것입니다. @Jutho 또는 @mbauman 은 나

나는 모호성에 대해 더 추가하고 싶지만 후행 토론 중 일부는 특정 핵심 사항을 요약했다고 생각합니다. 아마도 나는 너무 극적으로 들릴 위험이있는 외부인 또는 두려움 때문에 이런 종류의 모호함에 더 민감 할 것입니다. 내 겸손한 의견으로는, 단순하고 미션 크리티컬 한 사고 연습은 단순 오류의 비용 / 편익 분석이 그만한 가치가없는 경로로 안내 할 수 있습니다.

# 10507 에서처럼 fastindex를 eachindex 주위의 래퍼로 구현해야 할 것입니다.

@timholy 빠른 선형 배열을 위해 eachindex 가 UnitRange를 반환하지 않는 이유가 있습니까? 여전히 유형이 안정적이며 호출자가 CartesianIndex를 얻도록하고 싶다면 CartesianRange를 수동으로 생성 할 수 있습니다 ( CartesianRange가 내보내지지 않으므로 eachindex(size(A)) 에 대한 메서드를 추가 할 수도 있습니다).

처음에는 그렇게했지만 @Jutho가 변경했다고 생각합니다. (그건 사실이 아니에요 경우에, 나는 아마 실현하지 않고 그것을 변경.) 나는 변화가 일관성을 위해 동기를 부여했다 맡기 (당신은 점점 믿을 수 있도록 CartesianIndex ) 그것에 감각의 일정 금액을 가지고있는, . 그러나 지적했듯이이를 보장하는 대안이 있습니다.

@Jutho , 어떤 생각?

eachindex 변경 한 기억이 없지만 그럴 수 있습니다. 배열 유형에 관계없이 일관된 결과를 얻는 것 외에는 그럴만 한 이유를 확실히 기억하지 못합니다. 그러나 효율적인 선형 인덱싱이있는 배열과없는 배열의 차이가 문서에 명확하게 설명되어 있다면 효율적인 선형 인덱싱을 사용하는 배열의 경우 eachindex 에서 선형 범위를 반환 할 수없는 이유가 없습니다.

@timholy , 귀하의 이전 게시물에 대한 응답으로 JuliaCon에 참석할 수 없으므로 CartesianIndex 에 대해 자유롭게 이야기하십시오 (어쨌든 마지막 손질 만 제공했습니다). 나는 이미 회의의 보고서와 비디오를 기대하고 있습니다.

기발한 생각 : 모든 차원 (차원> 2 포함)의 A 배열의 경우 A' 는 A 의 인덱스를 순환 적으로 순회 할 수 있습니다. 따라서 A'[i, j, k] == A[j, k, i] . 이것은 MATLAB에서와 같이 해석 될 때 행 및 열 "벡터"(즉, 각각 [n, 1] 및 [1, n] 2d 배열)에 대한 일반적인 전치뿐만 아니라 2d 배열에 대한 일반적인 행렬 전치로 축소됩니다. 따라서 2D 열 "벡터"를 실제 코 벡터에 매핑하거나 2D 행 "벡터"를 실제 벡터에 매핑하지 않습니다. (나는이 속성이 좋다고 생각하지만 다른 사람들은 동의하지 않을 수 있습니다.) 배열 객체로 해석되는 행렬 및 벡터에 대해 A'' == A' 및 v'' == v _ 아이덴티티를 제공합니다 _. 위에서 논의한 것과 같은 종류의 유형 계층 (진짜 벡터와 코 벡터가 추상 배열과 충분히 구별되는 경우)이 주어지면 ' 에는 선형 대수 개념에 해당하는 실제 벡터와 코 벡터에 대해 완전히 다른 방법이 제공 될 수 있습니다. v'' == v 만족시킬 필요가 없습니다 (하지만 사람들이 원하는대로 결정했다면 가능합니다).

명확하게 말하면, 나는 ' _needs_ 차원이 2보다 큰 배열에 대해 어떤 방법을 가질 필요가 없다고 생각하지 않지만, 위의 제안을 보지 못했습니다 ( "인덱스 반전이 의미하는 것이 아니라면 ") 그냥 언급하겠다고 생각했습니다. 내가 생각하는 가장 큰 해악은 개념적이다 : (약간 임의의) 조합 연산을 일반적으로 선형 대수의 영역에서 취한 연산자와 결합하는 것이다. 이것에 대해 우리가 선형 대수 개념을 순수한 데이터 중심 개념으로 확장하려고 할 때 (이 전체 논의에서 입증 된 바와 같이) 적어도 어느 정도의 그러한 충돌이 불가피하다고 대답 할 수 있습니다. 따라서 우리는 다차원 배열 차원에 대해 일반적으로 ' 가 예상되는 경우로 축소되는 한 일반적으로 수행해야하는 작업을 결정하는 부산물로 다차원 배열의 순환 순열에 대한 편리한 속기를 거둘 수 있습니다 A'(k)[I] 가 A[I] 의 인덱스를 주기적으로 순열하도록 정수 인수를 취하는 메소드를 추가하여 A'(ndims(A))[I] == A[I] 및 A'(-k)[I] 가 인덱스를 순열하도록 할 수도 있습니다. 반대 방향으로.

그냥 생각.

transpose 가 다차원 배열에 대해 정의 된 경우 여전히 A''=A 만족하는 것이 좋습니다. 즉, 자체 역입니다. 이것은 이전 제안과 직접 ​​충돌합니다.

공정 해. 내가 말했듯이, 내 제안은 전치의 선형 대수적 중요성과 d> 2 경우에 부과하는 배열 중심 중요성 사이에서 균열이 커지는 것을 편안하게 할 때만 (잠재적으로) 매력적입니다. 내 추론은 그 균열이 이미 (종류) 발생하는 한, 방법이 완전히 사용되지 않는 한, 인덱스를 필요로하지 않는 한 순열 인덱스에 대한 속기를 갖는 것이 깔끔 할 수 있다는 것입니다. d = 2 케이스가 작동하도록 특별 대우. 당신 (@Jutho)이 언급했듯이, 2d 케이스의 전치 차원이 선형 대수적 중요성을 갖는 것은 편리한 우연의 일입니다 (그리고 그 문제에 대해 (공) 벡터를 2d 배열로 식별 한 후에 만), 그래서 아마도 우리는 d> 2에 대해 transpose 의 수학적 속성 (예 : A'' == A 필요)에 대해 까다로울 필요가 없습니다.이 경로를 사용하려는 경우 잠재적으로 유용한 방법이 많이 있습니다. 할당 됨, 예 : A' 주기적으로 한 번 순열, A'(k) 주기적으로 k 번 순열, A'(I) 대해 I::Array{Int, 1} 길이 <= ndims(A) 주기적으로 나열된 인덱스 순열로 I , 그리고 A'(p) 에 대해 p::Permutation 길이 <= ndims(A) 순열로 지수에 따라 p . 하지만 가장 좋은 방법은 패키지를 만들어서 잡을 수있을만큼 유용한 지 확인하는 것입니다.

예를 들어 2014 년 10 월 16 일 StefanKarpinski와 2015 년 3 월 22 일 simonbyrne이 언급 한 두 가지 변경 / 설명을지지하지만 한 가지 규정이 있습니다.

1. transpose 는 일반 텐서가 아닌 벡터 및 2 차원 행렬에만 사용해야합니다.
2. 연산자 * 및 transpose 는 계산이 끝날 때 후행 단일 차원을 삭제해야합니다. 그렇지 않으면 후행 단일 치수가 보존 될 수 있습니다.

이 두 가지 변경 사항은 많은 편의를 제공하고 전통적인 선형 대수 작업 내에서 많은 모호성을 해결합니다. 그들은 개별적으로 고려할 수있는 일반 배열 인덱싱이나 텐서 대수에 대해 의도적으로 아무 말도하지 않습니다. (특히 텐서 전치는 행렬 / 벡터 전치와는 완전히 별개의 연산으로 간주되어야합니다.)

이 제안에 따르면 행렬 곱셈 및 전치로 작업 할 때 벡터와 1 열 행렬 사이에 본질적으로 구분이 없으며 스칼라, 길이가 1 인 벡터 및 1x2 사이에 의미있는 구분이 없습니다. -1 행렬. 그러나 x' 는 벡터가 아니라 1xn 행렬입니다.

반면에 데이터를 보관하기 위해 모든 크기의 배열을 구성 할 수 있습니다. 곱셈과 전치의 선형 대수 개념이 관련되지 않기 때문에 단일 차원은 삭제되지 않습니다.

아래는 제안 된 변경 사항이 적용된 Julia 세션의 가상 사본입니다.

먼저 스칼라, 두 개의 벡터, 행렬을 정의합니다.

julia> alpha = 2.0
2.0

julia> x = [1.0; 2.0; 3.0]
3-element Array{Float64,1}:
 1.0
 2.0
 3.0

julia> y = [4.0; 5.0; 6.0]
3-element Array{Float64,1}:
 4.0
 5.0
 6.0

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3x3 Array{Float64,2}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

스칼라-벡터 곱셈은 외부 차원이 있어도 작동하며 결과는 항상 벡터입니다.

julia> alpha*x
3-element Array{Float64,1}:
 2.0
 4.0
 6.0

julia> alpha*x[:,[1]]
3-element Array{Float64,1}:
 2.0
 4.0
 6.0

Transpose는 진화입니다.

julia> x'
1x3 Array{Float64,2}:
 1.0  2.0  3.0

julia> x''
3-element Array{Float64,1}:
 1.0
 2.0
 3.0

julia> x==x''
true

julia> x'''
1x3 Array{Float64,2}:
 1.0  2.0  3.0

행렬에 1 열 행렬을 곱하면 행렬-벡터 곱과 동일한 결과가 생성됩니다.

julia> A*x
3-element Array{Float64,1}:
 14.0
 32.0
 50.0

julia> A*x[:,[1]]
3-element Array{Float64,1}:
 14.0
 32.0
 50.0

1 행 행렬 곱하기 행렬은 1 행 행렬과 같습니다.

julia> x'*A
1x3 Array{Float64,2}:
 30.0  36.0  42.0

내적은 스칼라이며 행렬-벡터 및 행렬-행렬 곱에 대한보다 일반적인 규칙에 의해 생성됩니다.

julia> x'*y
32.0

julia> x'*y[:,[1]]
32.0

외부 제품은 특별한 것이 아닙니다.

julia> x*y'
3x3 Array{Float64,2}:
  4.0   5.0   6.0
  8.0  10.0  12.0
 12.0  15.0  18.0

julia> x[:,[1]]*y'
3x3 Array{Float64,2}:
  4.0   5.0   6.0
  8.0  10.0  12.0
 12.0  15.0  18.0

벡터 곱하기 벡터는 오류입니다.

julia> x*y
ERROR: `*` has no method matching *(::Array{Float64,1}, ::Array{Float64,1})

벡터 곱하기 행렬은 오류입니다.

julia> x*A
ERROR: DimensionMismatch("*")
 in gemm_wrapper! at linalg/matmul.jl:270
 in * at linalg/matmul.jl:74

행렬 곱셈은 연관성이 있습니다.

julia> (x*x')*y
3-element Array{Float64,1}:
 32.0
 64.0
 96.0

julia> x'*y
32.0

julia> x*(x'*y)
3-element Array{Float64,1}:
 32.0
 64.0
 96.0

julia> norm((x*x')*y-x*(x'*y))
0.0

편집 : 제품의 내부 차원 강등과 관련된 두 가지 예를 삭제했습니다. 그들은 현재 토론에 많은 영향을 미치지 않았습니다.

후행 싱글 톤 차원을 버리는 것은 유형이 안정적인 작업이 아니기 때문에 관련 작업의 유형 안정성을 잃을 까 봐 걱정됩니다.

내가보기에, 전체 코 벡터 사업은 제거 될 유형에 따라 알려진 단일 차원을 갖는 것에 관한 것입니다. 또한 우리는 벡터와 하나의 열만있는 행렬 사이의 구분을 유지하기 위해 매우 열심히 노력해 왔지만이 제안은 x'' 와 같은 경우에 따라 이러한 구분을 제거합니다.

이단 적 제안 : 유형 매개 변수에서 차원을 삭제하고 런타임에 모든 차원 / 크기를 확인하면 어떨까요? (어쨌든 상당한 양의 작업을 수행하게됩니다.) 또한 크기를 유형 매개 변수로 인코딩하는 유형에 대해서는 차원 매개 변수를 그대로 둡니다. (Ducks, 2 주 동안 숨어서 그의 github 계정을 @SomeoneWhoCertainlyIsntTimHolyUhUhNoWay로 변경합니다.)

(물론 # 10525만으로도 나 자신에게 불평 할 것이다.)

FWIW, 그것은 그렇게 미친 생각이 아니라고 말하고 싶습니다. 예를 들어 Torch가 작동하는 방식이고 Torch 개발자는 Julia의 유형 시스템 내 차원 인코딩에 불만을 표명했습니다.

@timholy 질문 : 선형 대수와 벡터의 전치에 관한 의미를 개선 할 수 있습니까?

CoVector / DualVector / TransposeVector 사용에 여전히 관심이있는 경우 새 TimHolyArray{DataType} _and_을 (를) 이해해야합니다. 2 (또는 1)보다 큰 차원 배열의 전치, 그렇지 않으면 tharray 차원이 2 (또는 1)보다 큰 경우 TransposeVector(tharray) 구성을 금지합니다. 실제로 모든 종류의 현재 컴파일 타임 오류 인 런타임 수준에서 오류가 발생해야합니다 (예 : 현재 정의되지 않아 형식 시스템에서 금지하는 곱셈).

다른 한편으로,이 새로운 클래스 내부에 전치 플래그를 구현하는 것은 나쁠 수 있습니다. 그것은 효율적이고 가벼운 컨테이너가되어야하는 것에 더 많은 복잡성을 추가합니다. 나는 그 옵션을 배제하고 컴파일러 / 타입 시스템에 힘든 작업을 맡기는 경향이 있습니다.

나는 당신의 아이디어에 반드시 반대하는 것은 아니지만 벡터 전치와 병렬로 수행 될 수있는 추가 문제인 것 같습니다.

@timholy : 이것이 갈 길인지 아닌지 정말 확신합니다. 차원에서 파견하는 것이 매우 유용하다고 생각하는 상황이 있습니다.

제안은 이것을 모든 어레이에 적용하는 것이 었습니다. 하지만 지금은 내 제안에 반대합니다. 많은 다차원 사례에서 N 차원 배열에 대해 N 루프를 생성해야하기 때문입니다. N 가 유형 매개 변수가 아닌 경우 더 이상이를 수행 할 수 없습니다.

예, 이것이 데카르트 매크로의 전체 요점이 아닙니까 (또는 아직 익숙하지 않은 단계적 함수 :-))?
치수를 템플릿 매개 변수로 사용하는 것이 정말 고통스러운 C ++에서도 비슷한 작업을 수행했습니다. 그러나 다른 배열 차원을 전문화하기 위해 큰 if 문이 필요했기 때문에 동적 변형이 제한되는 상황이있었습니다.

신청:

1. 현재 행렬 곱셈 동작의 이름을 timesfast 바꾸고 현재 전치 동작의 이름을 transposefast 바꿉니다.
2. (*) 및 transpose 를 수정하여 이전 주석 에서와 같이 후행 단일 치수를 자릅니다. 예를 들어 u'*v 는 스칼라가되고 v'' 는 벡터가되고 (v*v')/(v'*v) 가 정의됩니다.

기존 동작은 유형이 안정적입니다. 제안 된 동작은 많은 선형 대수 텍스트의 규칙을 따릅니다. 둘 다 가치가 있습니다. 아마도 Julia는 둘 다 가져야 할 것입니다.

교실에서 Julia를 사용하고 싶기 때문에 효율성보다 편리함을 중시하는 기본 동작에 투표합니다.

이 매우 긴 스레드에 대한 속도를 높여준 여러 기여자에게 감사드립니다!

@briansutton : 나는 당신이 요구하는 것을 정말로 재고해야한다고 생각합니다. 곱셈의 의미를 재정의 할 것을 제안하기 전에 Julia가 어떻게 작동하는지 더 깊이 이해할 때까지 기다리시기 바랍니다.

이 문제는 가능한 한 많은 특수 사례를 피할 수있는 방법에 관한 것입니다.

단일 치수의 퍼징을 허용하는 규칙은 단일 치수 중 하나가 실제로 관심을 갖는 순간에 분해됩니다. "[모든] 후행 단일 차원 자르기"규칙을 사용하면 v 가 요소가 1 개인 벡터이면 v' 가 스칼라이므로 v'' 도 스칼라. 따라서이 제안에서도 v == v'' 가 항상 보유하는 것은 아닙니다.

"배열에 차원이 2 인 경우 마지막 후행 단일 차원 만 자르도록"규칙을 수정할 수 있습니다. 그러나이 수정 된 규칙을 사용하더라도 외부 곱 v * w' 는 행렬 곱셈의 정의에서 자동으로 따르지 않고 대신 Vector * Matrix 의 고유 한 특수한 정의 여야하며 정의는 다음과 같아야합니다. "모양이 (N) x (1, M))이 아니면 오류를 던지십시오.

@jiahao :

벡터와 행렬을 사용하여 선형 대수를 수행 할 때 스칼라, 요소를 1 개 가진 벡터 및 1x1 행렬 사이에 어떤 차이도 그리지 않으려 고합니다. 현재 다양한 작업으로 세 가지 개체 중 하나가 생성됩니다. 내 제안은 행렬 곱셈과 전치 연산에 대해 세 가지 중 하나를 선호하는 표현으로 선택하는 것입니다.

첫 번째 예제 ( v==v'' )와 관련하여 처음에 요소 1 개 벡터 v 를 생성하는 것을 피하고 싶습니다.

두 번째 예와 관련하여 예, v*w' 는 설명대로 처리해야한다고 생각합니다. 행렬 곱셈 및 전치 작업을 할 때 벡터 v 및 Nx1 행렬 v[:,[1]] 가 내부 표현이 다르더라도 동일한 수학적 객체를 나타내기를 원합니다. 이를 위해서는 N 벡터 x 1xM 행렬을 처리하기위한 특수 코드가 필요합니다.

유형 안정성이 중요하다는 것을 여전히 확신하지 못하는 것 같습니다.

@briansutton : 현재 유형 시스템이 Julia 코드를 실행할 수있는만큼 빠르게 제안을 실행하는 데 필요한 기계를 구현하는 것이 매우 유익하다고 생각합니다. 나는 예측 가능한 성능과 C 메모리 레이아웃 호환성을 제공하는 Julian 목표를 고려할 때 언급 한 목표를 달성 할 수 없다고 생각합니다.

앞뒤로 진행되는 논쟁을 이해하는지 잘 모르겠지만 한 가지 눈에 띄었습니다. 아마도 그것은 희망적인 생각일지도 모르지만, 컴퓨터가 인간의 두뇌만큼 빨리 생각할 수 있다면 좋을 것입니다. 내 말은 Brian Sutton이 "선호하는 표현을 고르는"프로그램에 대해 이야기 할 때, 우리가 수학을 할 때 할 수있는 것처럼 생각할 수있는 프로그램을 구상한다는 것입니다. 아마도 오늘날의 기술로는 불가능하고 일이 너무 느려질 것입니다. 하지만 좋지 않을까요 ...

저는 물리학 자이자 Julia의 적극적인 사용자입니다.

나는 더 이상 날씨를 유지하거나 모든 후행 단일 치수를 삭제하는 것을 선호하지 않습니다.

그러나 여기서는 밀접하게 관련된 문제를 제기하고 싶습니다.

현재 Julia 구현 :

V를 3 차원 랭크 -1 텐서 (벡터)라고합시다.
V [1]은 1 차원 랭크 -1 텐서가 아닌 스케일러를 제공합니다.

A를 3x4x5 랭크 -3 텐서라고합니다.
B = A [1, :, :]는 1x4x5 rank-3 텐서를 제공합니다.

위의 두 가지 동작은 일관성이 없습니다.

다음 인덱싱 / 슬라이딩 기능을 강력하게 선호합니다.

A를 3x4x5 랭크 -3 텐서라고합니다.
B = A [1, :, :]는 4x5 rank-2 텐서를 제공합니다.
C = A [1 : 1, :, :]은 1x4x5 rank-2 텐서를 제공합니다.
(현재 위의 두 가지는 동일한 결과를 제공합니다)

V를 랭크 1 텐서로 지정
B = V [1]은 스케일러를 제공합니다.
C = V [1 : 1]은 1-dim rank-1 tensor를 제공합니다.

이 기능은 텐서의 모양을보다 쉽게 ​​변경하는 데 도움이되며 후행 싱글 톤 인덱스를 허용 할 때 유용합니다.

베스트

샤오강

보낸 사람 : esd100 [[email protected]]
전송 : 2015 년 6 월 9 일 화요일 오후 9:46
받는 사람 : JuliaLang / julia
참조 : Xiao-Gang Wen
제목 : Re : [julia] 벡터 전치 진지하게 받아들이 기 (# 4774)

앞뒤로 진행되는 논쟁을 이해하는지 잘 모르겠지만 한 가지 눈에 띄었습니다. 아마도 그것은 희망적인 생각일지도 모르지만, 컴퓨터가 인간의 두뇌만큼 빨리 생각할 수 있다면 좋을 것입니다. 내 말은 Brian Sutton이 "선호하는 표현을 고르는"프로그램에 대해 이야기 할 때, 우리가 수학을 할 때 할 수있는 것처럼 생각할 수있는 프로그램을 구상한다는 것입니다. 아마도 오늘날의 기술로는 불가능하고 일이 너무 느려질 것입니다. 하지만 좋지 않을까요 ...

—
이 이메일에 직접 답장하거나 Gi tHubhttps : //github.com/JuliaLang/julia/issues/4774#issuecomment -110554622에서 확인하세요.

내 말은 : C = A [1 : 1, :, :]은 우리에게 1x4x5 랭크 -3 텐서를 줄 것입니다.

샤오강

보낸 사람 : Xiao-Gang Wen [[email protected]]
전송 : 2015 년 6 월 22 일 월요일 오후 12:01
받는 사람 : JuliaLang / julia; JuliaLang / julia
참조 : Xiao-Gang Wen
제목 : RE : [julia] 벡터 전치 진지하게 받아들이 기 (# 4774)

저는 물리학 자이자 Julia의 적극적인 사용자입니다.

나는 더 이상 날씨를 유지하거나 모든 후행 단일 치수를 삭제하는 것을 선호하지 않습니다.

그러나 여기서는 밀접하게 관련된 문제를 제기하고 싶습니다.

현재 Julia 구현 :

V를 3 차원 랭크 -1 텐서 (벡터)라고합시다.
V [1]은 1 차원 랭크 -1 텐서가 아닌 스케일러를 제공합니다.

A를 3x4x5 랭크 -3 텐서라고합니다.
B = A [1, :, :]는 1x4x5 rank-3 텐서를 제공합니다.

위의 두 가지 동작은 일관성이 없습니다.

다음 인덱싱 / 슬라이딩 기능을 강력하게 선호합니다.

A를 3x4x5 랭크 -3 텐서라고합니다.
B = A [1, :, :]는 4x5 rank-2 텐서를 제공합니다.
C = A [1 : 1, :, :]은 1x4x5 rank-2 텐서를 제공합니다.
(현재 위의 두 가지는 동일한 결과를 제공합니다)

V를 랭크 1 텐서로 지정
B = V [1]은 스케일러를 제공합니다.
C = V [1 : 1]은 1-dim rank-1 tensor를 제공합니다.

이 기능은 텐서의 모양을보다 쉽게 ​​변경하는 데 도움이되며 후행 싱글 톤 인덱스를 허용 할 때 유용합니다.

베스트

샤오강

보낸 사람 : esd100 [[email protected]]
전송 : 2015 년 6 월 9 일 화요일 오후 9:46
받는 사람 : JuliaLang / julia
참조 : Xiao-Gang Wen
제목 : Re : [julia] 벡터 전치 진지하게 받아들이 기 (# 4774)

앞뒤로 진행되는 논쟁을 이해하는지 잘 모르겠지만 한 가지 눈에 띄었습니다. 아마도 그것은 희망적인 생각일지도 모르지만, 컴퓨터가 인간의 두뇌만큼 빨리 생각할 수 있다면 좋을 것입니다. 내 말은 Brian Sutton이 "선호하는 표현을 고르는"프로그램에 대해 이야기 할 때, 우리가 수학을 할 때 할 수있는 것처럼 생각할 수있는 프로그램을 구상한다는 것입니다. 아마도 오늘날의 기술로는 불가능하고 일이 너무 느려질 것입니다. 하지만 좋지 않을까요 ...

—
이 이메일에 직접 답장하거나 Gi tHubhttps : //github.com/JuliaLang/julia/issues/4774#issuecomment -110554622에서 확인하세요.

당신이 요구하는 것은 현재 slice 작동 방식입니다. 내 감각은 A[stuff] 이 slice(A, stuff) 의 동의어가 될 것이므로 아마도 당신의 소원을 얻을 것입니다.

친애하는 Tim :

팁 주셔서 감사합니다. 나는 슬라이스를 시도했습니다. 내 필요에 맞지 않습니다. Slice는 :: Array 데이터 유형을 사용하는 다른 코드에서 사용할 수없는 새로운 데이터 유형 "subarray"를 생성합니다.

"subarray"데이터 유형을 허용하도록 다른 코드를 변경할 수 있습니다.

샤오강

보낸 사람 : Tim Holy [[email protected]]
전송 : 2015 년 6 월 22 일 월요일 오후 5:32
받는 사람 : JuliaLang / julia
참조 : Xiao-Gang Wen
제목 : Re : [julia] 벡터 전치 진지하게 받아들이 기 (# 4774)

당신이 요구하는 것은 슬라이스가 현재 어떻게 작동하는지입니다. 제 생각에는 A [stuff]가 slice (A, stuff)의 동의어가 될 것이므로 아마도 당신의 소원을 얻을 것입니다.

—
이 이메일에 직접 답장하거나 Gi tHubhttps : //github.com/JuliaLang/julia/issues/4774#issuecomment -114268796에서 확인하세요.

코드에서 AbstractArray 대신 구체적인 Array 유형을 사용하는 데 실제로 의존하는 것이 있습니까? 작업을 수행하려면 Array 를 AbstractArray 로 검색 / 바꾸기 만하면됩니다.

친애하는 Scott

팁 주셔서 감사합니다.

샤오강

보낸 사람 : Scott P. Jones [[email protected]]
전송 : 2015 년 6 월 25 일 목요일 오전 9:55
받는 사람 : JuliaLang / julia
참조 : Xiao-Gang Wen
제목 : Re : [julia] 벡터 전치 진지하게 받아들이 기 (# 4774)

코드에서 AbstractArray 대신 구체적인 Array 유형을 사용하는 데 실제로 의존하는 것이 있습니까? 작업을 수행하기 위해 Array를 AbstractArray로 검색 / 교체하는 것 이상이 필요하지 않을 수 있습니다.

—
이 이메일에 직접 답장하거나 Gi tHubhttps : //github.com/JuliaLang/julia/issues/4774#issuecomment -115265047에서 확인하세요.

그게 당신을 위해 속임수를 쓰 셨나요? 기꺼이 도와 드리겠습니다!

@wenxgwen , 또는 copy(slice(A,...)) 를 호출하여 이미 존재하는 함수와 기본적으로 작동해야하는 새로운 Array 에서 슬라이스 사본을 가져올 수 있습니다.

이 문제를 해결하는 것은 이제 유리한 노력 이되었습니다.

이 문제를 해결하는 것이 이제 3 개의 쉼표로가는 경로에서 중요하기 때문에 ...

그러나 진지하게. 나는 토론을 완전히 읽으려고 노력했지만 이것이 이전에 제안되지 않았다는 것을 보장 할 수 없습니다.

AbstractArray 정의를 확장하여 기본 데이터가 행 기반 저장소인지 열 기반 저장소인지를 정의하는 추가 특성 (LinearIndexing과 유사한?)을 가질 수 있습니까? 이렇게 추가하면 다음과 같은 속성이 열립니다 (이름에 초점을 맞추지 말고 개념에만 집중하십시오).

v --> length-2 Vector{Col}
  [ 1
    2 ]

v'  --> length-2 Vector{Row}
  [ 1 2 ]

m --> 2x2 Matrix{Col}
  [ 1 3 
    2 4 ]

m' --> 2x2 Matrix{Row}
  [ 1 2 
    3 4 ]

Some operations:
v'  --> length-2 Vector{Col}
v'' == v
v*v or v'*v'  --> either error, or do element-wise multiplication
v' * v --> scalar
v * v' --> 2x2 Matrix  (could be Row or Col??)
v' * m --> 2-length Vector{Row}
v * m --> either error or broadcasting operation
m * v --> either error or broadcasting operation
m * v' --> 2-length Vector{Col}

Indexing:
v[2] --> 2
v[1,2] --> error
v'[1,2] --> 2
m[1,2]  --> 3
m'[1,2]  --> 2

Size:
length(v)  --> 2
length(v')  --> 2
size(v)  --> (2,)
size(v')  --> (2,)
length(m)  --> 4
size(m)  --> (2,2)

분명히이 제안에는 많은 정의가 누락되어 있지만 토론을 시작할 수 있습니다. 열-인덱스와 행-인덱스 저장소를 동시에 지원하고 그 과정에서 일부 문제를 "수정"할 수 있습니까?

Julia가 행 기반 스토리지 였으면 좋겠습니다. 루프 및 기타 여러 작업에 대해 자연스럽게 생각하는 방식이기 때문입니다. (그리고 나는 이런 식으로 생각하는 유일한 사람이라고 생각하지 않습니다) 댓글 부탁드립니다!

생성자가 행이나 열을 사용하는 것은 흥미로운 생각입니다. 나는 GitHub 이슈 시스템의 깊숙한 곳에서 전에 논의되었다고 생각합니다. 내가 틀렸을 수도있다!

대부분의 교과서는 수학에 열을 사용하고 Julia에서는 대신 행을 사용하기 위해 모든 것을 변경할 필요가 없기 때문에 개인적으로 열 기반 저장소를 선호합니다. 처음에는 이상하게 느껴졌지만 금방 내 작업에 문제가되지 않았습니다. 행으로 더 쉽게 표현되는 알고리즘이 있지만 이것이 필요할 때 비표준 스토리지를 사용할 수 있어야하는 좋은 이유입니다. 함수를 호출 할 때 어떤 유형이 있는지에 대한 질문이 없도록 내보내는 함수가있을 때 항상 열 주 행렬 또는 열 벡터를 반환하는 규칙이 있기를 바랍니다. 그렇지 않으면 어떤 유형이 반환되는지 항상 찾아봐야 할 때 매우 지저분 해지고 사용하기 불편해질 수 있습니다.

열 기반과 행 기반은이 문제의 범위에 포함되지 않습니다.

@tbreloff 나는 아이디어를 매우 좋아합니다. 행 중심의 언어 / 라이브러리와 더 쉽게 인터페이스 할 수 있으면 좋을 것입니다.

Jiahao는 row-major와 column-major를 선호하는 것이 주제에서 벗어난 것이 맞습니다. 이것의
"줄리아"방식으로 전치 문제를 해결하는 멋진 부작용
(파라 메트릭 유형 및 단계적 함수)는 사람들에게 더 많은 유연성을 제공합니다.
저장 형식.

행 / 열 특성을 배열에 추가하는 아이디어가 마음에 들지 않으면
TransposeView {T, N}을 사용하여 똑같은 작업을 수행 할 수 있지만
잘 구현하는 것이 더 복잡 할 것이라고 의심합니다.

추가 특성의 가장 큰 단점은 신규 사용자에 대한 혼란입니다.
그게 제가 화해하기 힘든 부분입니다.

2015 년 9 월 26 일 토요일, Scott P. Jones [email protected]
썼다 :

@tbreloff https://github.com/tbreloff 저는 아이디어가 매우 마음에 듭니다 . 그것
언어 / 라이브러리와 더 쉽게 인터페이스 할 수 있으면 좋을 것입니다.
행 주요입니다.

—
이 이메일에 직접 답장하거나 GitHub에서 확인하세요.
https://github.com/JuliaLang/julia/issues/4774#issuecomment -143436947.

호출 과부하가 디자인 공간을 전혀 변경합니까? 위의 경우 때때로 * 의 의미에 일종의 모호함이있는 것처럼 보였습니다. 특히, v::Covector * w::Vector 가 스칼라를 반환하기를 원할 때 행렬 곱셈 대신 * 실제로 " w 아래에있는 v w 매핑"으로 취하고 있습니까? 그렇다면 벡터 자체가 코 벡터에 대한 선형 맵이기 때문에 w::Vector * v::Covector 가 스칼라를 반환하도록 유사하게 요구할 수 없습니까?

아마도 대신 과부하에 도움이 될 것입니다 call 쓰는 v(w) 은 "아래의지도를 표시하기 위해 v 에 작업을" w , 유사에 대한 w(v) -둘 다 스칼라를 반환합니다. 이것이 2d 배열의 경우 배열 연산과 선형 대수 연산이 공유하는 의미를 수용하는 데 더 많은 여유를 허용할까요?

그렇다면 벡터 자체가 covector에 대한 선형 맵이기 때문에 w :: Vector * v :: Covector가 스칼라를 반환하도록 유사하게 요구할 수 없습니까?

저는 우리가 1 학년 대학에서 많은 사람들이 보는 행렬과 벡터 관습을 따르려고 노력하고 있다고 생각합니다. 이것은 비 교환적이고 벡터 * 전치 벡터-> 행렬 (랭크 -1의, 즉 하나 (0이 아닌) 단수)을 가지고 있습니다. 값). 당신이 쓴 것은 추상적 인 선형 대수 개념처럼 들리는데, 벡터와 공동 / 이중 벡터는 서로에서 어떤 스칼라로의 맵인데, 괜찮지 만 Julia와 MATLAB에서 시도한 것과는 약간 다릅니다 (IMHO). 나는 당신이 쓴 것을 내적, dot() 또는 ⋅ 로 해석 할 수 있다고 생각합니다. (우리는 아마도 covector에 대해 정의해야한다고 생각합니다.) -product, 현재 비누 적 * 사용하면 두 가지 동작을 모두 작성하고 표현할 수 있습니다.

호출 규칙 v(w) , 내적에 대해 w 방향으로 v 금액을 원한다고 똑같이 말할 수 있습니다. 이는 인덱싱 연산자 v[w] 사용을 제안합니다

내적에 대해 w 방향으로 v 의 양을 원한다고 똑같이 말할 수 있는데, 이는 인덱싱 연산자 v[w] 사용함을 의미합니다.

이 제안은 인덱싱의 의미를 거의 따르지만 그렇지 않습니다. 또한 v 이 Vector{<:Integer} 경우 벡터 인덱싱에 대한 현재 지원과 충돌합니다.

v :: Vector{T<:Real} 경우 v[1] 는 내적 v⋅e₁ 와 동일합니다. 여기서 e₁ 는 첫 번째 축의 표준 기저 벡터입니다. 따라서 간단한 인덱싱이 실제로 기능입니다.

   v[n] : n :: Integer --> y = (v ⋅ eₙ) :: T

벡터 인덱싱의 경우 v[[1, 2]] 는 [v⋅e₁, v⋅e₂] v 를 {e₁, e₂} 걸쳐있는 부분 공간으로 투영 한 결과 인 v' * [e₁ e₂] 의 결과입니다

따라서 벡터 인덱싱은

   v[I] : I :: Vector{<:Integer} --> y = v' * [eₙ for n in I] :: Vector{T}

v[w] = (w ⋅ v) v 를 만들 겠다는 제안은 n 인덱스 모음 ( w 로 지정됨)에서 표준 기저 벡터 모음으로의 암시 적 매핑을 제거하므로이 정의와 일치하지 않습니다. eₙ , 현재 색인 생성 규칙이 작동하는 데 필요합니다.

스코프를 벡터 전치로만 제한하면 두 가지 옵션이 있다고 생각합니다. 오류로 만들거나 특수 코 벡터 유형을 도입 할 수 있습니다. Julia에서 벡터의 일급 특성을 감안할 때 전자는 매우 힘든 판매라고 생각합니다. 일관되게 수행하려면 벡터가 행렬의 대수에 완전히 참여하는 것을 완전히 허용하지 않아야합니다.

그래서 저는 코 벡터를 촬영했습니다. 작업이 많고 안타깝게도 더 많은 시간을 할애 할 수 없습니다. 나는 누군가가 그것을 가지고 달리거나 우리가 어려움으로부터 배우고 도망 치기로 결정할 것이라는 희망으로 여기에 게시합니다. 그러나 나는 뷰로 전치하는 분기 건물과 코 벡터로 구현 된 행렬 곱셈을 가지고 있습니다. 일부 선택된 테스트는 통과하지만 depwarn=error 없이 만 통과합니다 (예 : ./julia -e 'using Base.Test; include("test/matmul.jl")' ). https://github.com/JuliaLang/julia/compare/mb/transpose

transpose 및 ctranspose 의 행렬 및 벡터에 사용할 두 가지 새로운 뷰 유형을 정의했습니다.

immutable MatrixTranspose{C,T,A} <: AbstractArray{T,2}
    data::A # A <: AbstractMatrix{T}
end
immutable Covector{C,T,V} 
    data::V # V <: AbstractVector{T}
end

C 매개 변수는 전치가 전치인지 아닌지를 나타내는 간단한 부울입니다. Covector는 AbstractArray 의 하위 유형이 _ 아닙니다 _. 이것은 디스패치가 합리적으로 작동하기위한 매우 강력한 요구 사항입니다.

몇 가지 단점 :

• 코 벡터는 확실히 복잡하며 접근 가능하고 엄격한 방식으로 문서화하는 것이 어려울 것입니다. 여기에서 언어가 도움이 될 수 있습니다. 간단히 RowVector 라고 부를 수 있습니다. 그럼에도 불구하고이 동작을 설명하려고 할 때 가장 먼저 부딪히는 어려움은 코 벡터의 모양에 대해 말하는 방법입니다 ( size 는 정의되지 않음). (m,n) 이 행렬의 모양이면 (m,) 는 벡터의 모양을 나타낼 수 있습니다. 튜플 표기법을 남용하면 코 벡터를 은밀하게 설명하여 (,n) 모양을 가질 수 있습니다.
  
  
  
  • 행렬 * 벡터는 (m,n) × (n,) → (m,)
  
  
  • 코 벡터 * 행렬은 (,m) × (m,n) → (,n)
  
  
  • 벡터 * 코 벡터는 (n,) × (,n) → (n,n)
  
  
  • 코 벡터 * 벡터는 (,n) × (n,) → α (스칼라)입니다.
  
  

• 여기서 이진 연산과 유형의 수는 정의해야하는 메서드의 수를 크게 조합하여 폭발적으로 만듭니다.

  • 돌연변이 : (변이, 비변이)
  • 조옮김 : (A, Aᵀ, Aᴴ) × (B, Bᵀ, Bᴴ).
  • 모양 : (매트 × 매트; Vec × 매트; 매트 × Vec, Vec × Vec). 이들 모두가 모든 전치 조합에서 지원되는 것은 아니지만 대부분은 지원됩니다.
  • 구현 : (BLAS, Strided, 일반 및 구조 매트릭스에 대한 전문화)

  이러한 작업 중 일부는 여러 디스패치 및 폴백 동작과 잘 맞아 떨어지지 만 여전히 각 연산자에 대해 _ 엄청난 수의 메서드입니다. 여기서 혼합 행렬 / 벡터 지원을 완전히 제거하면 작업을 단순화하는 데 확실히 도움이됩니다.



• 모든 스칼라 차원을 삭제하는 문제를 즉시 해결하지는 못합니다. 스칼라 차원을 삭제할 때 모든 종류의 벡터 전치를 지원하면 복잡한 켤레와 관련하여 모호한 영역에있게됩니다 (https://github.com/JuliaLang/julia/pull/13612 참조). 아마도 우리는 A[1,:] 가 코 벡터를 반환하도록 할 수 있지만 잘 일반화되지 않고 슬라이스에서 비 AbstractArray를 반환하는 것은 상당히 이상 할 것입니다. 사람들이 # 13612를 시도해보고 특별히 벡터의 켤레 전치로 인해 문제가 발생하는 경우를 찾을 수 있다면 좋을 것입니다. 현재 벡터 전치 의미론에서도 똑같이 나쁘고 Covector를 노출 할 필요가 없습니다.

몇 가지 장점 :

• Ax_mul_Bx 에 대한 특수 구문 분석 대신 직접 dispatch를 사용하는 것은 큰 승리입니다. BLAS의 API로 매우 잘 구성됩니다. 일반적으로 알고리즘의 가장 안쪽 수준에서 활용을 원하므로이 정보를 인수와 함께 유지하는 것이 훨씬 더 합리적입니다. BLAS 호출의 경우 간단한 함수를 사용하여 전치 문자 ( ntc )를 조회 할 수 있습니다.
• v'v 가 스칼라를 반환하기 때문에 벡터와 코 벡터 간의 곱셈은 이제 연관성이 있습니다. 이제 v'v*v 를 왼쪽에서 오른쪽으로 평가하고 행렬 형성을 피할 수 있습니다.
• 이렇게하면 모든 벡터를 후행 싱글 톤 차원이있는 것처럼 처리하는 경우에만 작동하는 Vector * Matrix를 제거 할 수 있습니다. 일반적으로 후행 싱글 톤 차원에 대한 지원을 완전히 제거하는 좋은 단계입니다.

기타 참고 사항 :

• 부울 유형 매개 변수로 표현되는 전치의 복잡성은 잘 작동하지만 종종 매개 변수를 잘못된 순서로 정의한 것처럼 느꼈습니다. 실제로 T 및 C 를) 제한하거나 캡처하려는 경우는 거의 없었습니다. 정의해야 할 자리 표시 자 유형 변수의 수 측면에서 다른 방법이 더 나은지 확실하지 않지만 적어도 AbstractArray{T} 와 일치합니다.
• 이것은 실제로 StridedArray 어려움을 악화시킵니다. * 대한 메소드 테이블을 읽는 것은 ::Union{DenseArray{T<:Union{Complex{Float32},Complex{Float64},Float32,Float64},2},MatrixTranspose{C,T<:Union{Complex{Float32},Complex{Float64},Float32,Float64},A<:Union{DenseArray{T,1},DenseArray{T,2},SubArray{T,1,A<:DenseArray{T,N},I<:Tuple{Vararg{Union{Colon,Int64,Range{Int64}}}},LD},SubArray{T,2,A<:DenseArray{T,N},I<:Tuple{Vararg{Union{Colon,Int64,Range{Int64}}}},LD}}},SubArray{T<:Union{Complex{Float32},Complex{Float64},Float32,Float64},2,A<:DenseArray{T,N},I<:Tuple{Vararg{Union{Colon,Int64,Range{Int64}}}},LD}} 와 같은 유형에서 상당히 어려운 일입니다. 물론, 나는 그것을 typealias로 작성했지만 이러한 모든 다른 유형 별칭 이름을 관리하는 것조차도 고통 스럽습니다 ( StridedMatOrTrans , QRCompactWYQorTranspose 등).
• 저는 이것을 SparseVector와 통합 할 기회가 없었지만 CSR 없이도 효율적으로 트랜스 포즈를 표현할 수 있기 때문에 큰 승리가 될 것입니다.
• Covector에서 스칼라 및 / 또는 비 스칼라 인덱싱을 정의해야합니까? 그렇다면 r[:] 또는 r[1:end] 무엇입니까? 벡터 또는 코 벡터입니까? 나는 우리가 할 수 있다면 이것을 정의하지 않고 벗어나려고 노력할 것이라고 생각합니다. 흥미롭게도 Matlab은 다른 벡터로 행 벡터를 인덱싱하는 데 매우 특별한 규칙 을 가지고 있습니다. 그들은 이상한 코너 케이스 ( r((1:end)') 는 r(1:end) 는 r(:)' 희생하면서 행-니스를 유지하려고 매우 노력합니다.

마지막으로, 여기에서 볼 수있는 대부분의 이점은 MatrixTranspose 유형 자체에 적용되는 것과 똑같이 적용된다는 점을 지적하고 싶습니다. 이것은 혼합 벡터 / 행렬 연산을 가능하게하기 위해 추상 대수를 너무 깊이 탐구하지 않고도 Covector가 아주 잘 작동 할 수 있음을 보여줍니다. 확실히 멋진 기능 (선형 대수와 함께 벡터를 일관되게 사용하는 기능)을 추가하지만 추가 복잡성이 가치가 있는지는 모르겠습니다.

호기심으로 @mbauman을 기억 C 를 도입하게 된 동기는 무엇입니까? 그냥 가질 수 없습니까?

transpose(::Matrix) -> MatrixTranspose
transpose(::MatrixTranspose) -> Matrix

? 나는 여기서 당신의 (예외적 인) 판단을 의심하는 것이 아니라, 당신이 이것을하게 만든 깨달음이 무엇인지 이해하기를 원합니다.

아마도 순열을 인코딩하는 튜플 매개 변수를 사용하여 PermutedDimensionArray 유형으로 일반화 할 수 있습니다. Covector 유형은 분명히 다른 목적을 가지고 있으며 별도의 것이어야합니다.

켤레 전치 (및 (A').' 대한 비전 치 켤레 배열)를 처리하는 방법이 필요합니다. 이를 수행하는 세 가지 분명한 방법이 있습니다.

• 활용을 하나의 MatrixTranspose 유형 내에서 부울 필드로 저장합니다. 생각해 보면 이것이 외부 BLAS와의 인터페이스를위한 최상의 옵션이라고 생각합니다. 하지만 네이티브 JuliaBLAS의 관점에서 보면 Julia / LLVM이 T.isconjugate ? conj(T[i,j]) : T[i,j] 를 루프 밖으로 끌어 올릴 수 있는지 확인하고 싶습니다.
• 활용 매개 변수가있는 유형. 이것이 제가 선택한 것이고, 저는 우리가 현재 Ac_mul_Bt 와 친구들을 통해 conjugate-ness에 대해 pseudo-dispatch를하고 있다는 사실에 영향을받은 것 같습니다. 또한 Julia가 수행 할 수있는 분기 제거 최적화에 대한 더 강력한 보증을 제공합니다. 그러나 나는 그것에 대해 열심히 생각하지 않았습니다. 스케치 구현을 시작하고 싶었고 Covector에 대해 더 걱정했습니다.
• 두 가지 유형, MatrixTranspose 및 MatrixCTranspose . 유형 매개 변수에 대해 동형이지만 두 개의 개별 래퍼 유형이 짜증나는 것을 발견했습니다. 추상 슈퍼 타입과 공용체 별칭이 도움이 될 수 있지만이 옵션에 대해 매개 변수를 선택하겠습니다.

이제 유형이 지정된 함수가있는 네 번째 옵션이 있다고 가정합니다.이 옵션은 전치 유형 내에 변환 함수를 저장합니다.하지만 함수가 빠르기 위해서는 유형 매개 변수도 필요합니다. 그러면 쉽게 전달되지 않는 유형 매개 변수이기도합니다.

conj 및 transpose 규칙을 사용하여 ConjugateView 래퍼를 사용할 수 있는지 궁금합니다. ConjugateView 가 MatrixTranspose 래퍼 안에 배치되도록합니다. . 즉, A a Matrix ,
A' = conj(transpose(A)) = transpose(conj(A)) 모두 MatrixTranspose{ConjugateView{Matrix}} (정보가없는 유형 매개 변수 삭제).

아, 네, 그것도 합리적입니다. 저는 켤레 전치가 하나의 원자 "물건"이라고 생각하는 경향이 있으므로 그 옵션을 놓쳤습니다. 비공 액 전치가 모양 변경과 마찬가지로 특수 하위 배열 인덱스 유형으로 표현 될 수있는 방법에 대해 생각하고있었습니다.

여러분들이 아직이 작업을하고있어 기쁩니다! 이것은 서사시 스레드입니다! 세 번의 환호 !!!

교차 링크 https://github.com/JuliaLang/julia/pull/6837#issuecomment -213123832

1.0 용으로 계획되어 있습니까?

두 가지 문제 (# 18056, # 18136)에서이 거대한 스레드를 지적했습니다.
그래서 나는 그것을 시도합니다.

이제 Julia에는 진정한 1 차원 벡터가 있습니다. _e.g._ mx[row,:] 는 더 이상 1xn 행렬이 아닙니다.
이것은 환영받는 변화입니다!

그러나 부작용으로 기존의 일부 문제가 더 분명해졌습니다.
나는 v*mx 가 1 차원 벡터에서 작동하지 않는다는 사실에 물었습니다.
수학적으로 자연스럽게 작동하고 1-d 벡터를 반환해야합니다.
일반 a*b 제품이 계약에 의해 정의 된 경우
첫 번째 용어의 마지막 색인과 두 번째 용어의 첫 번째 색인.

현재 Vector-Matrix 제품의 메서드 서명은 다음과 같습니다.
(*)(A::AbstractVector, B::AbstractMatrix) = reshape(A,length(A),1)*B
이 메서드는 v*mx 아닌 v*v' 케이스에 사용됩니다.
(이 점을 지적 해 주신 @andreasnoack 에게 감사드립니다.)
분명히 하나의 방법을 둘 다 사용할 수는 없습니다.

Julia는 Matlab과 같은 계약으로 어려움을 겪고있는 것 같습니다.
하지만 Matlab에는 1 차원 벡터가 없으며 1xn 및 nx1 행렬 만 있습니다.
자연스럽고 많은 것들이 여기에 문제가 될 수 있습니다.
Julia는 큰 이점이 될 진정한 1 차원 벡터를 가지고 있습니다.
정말 일관된 자체 상태에 도달하면 좋을 것입니다.

Fortran은이 경우에 따라야 할 훨씬 더 좋고 일관된 예입니다.
transpose 연산은 Fortran의 행렬에 대해서만 정의됩니다.
진정한 1 차원 벡터에서 1xn 행렬을 만드는 것은 단순히 전치가 아닙니다.
matmul 의 경우 # 18056에 인용 된 Metcalf 책 발췌를 참조하십시오.

@alanedelman 의 원래 요점이 대부분 정확하다고 생각합니다.

여기에 기존 문제를 간단히 해결할 수있는 제안이 있습니다.
가능한 한 현재 상태를 존중하면서 :

• v' 그대로 1 차원 벡터 v 에서 1xn 행렬을 생성 할 수 있습니다.
• rowmx 및 colmx 함수가 더 좋을 수 있지만 v' 는 너무 널리 퍼져서 변경할 수 없습니다.
• 진정한 1 차원 벡터를 만들기위한 vec 함수가 이미 있습니다.
• v' 의 역이 v'' 아니라 vec(v') 이지만 우리는 그것과 함께 살 수 있습니다
• a*b 제품은 항상 마지막 인덱스 계약을 체결한다 a 과의 첫 번째 인덱스 b
• * 연산자는 내부 또는 외부 제품에 사용할 수 없습니다.
• 내부 제품의 경우 이미 dot 기능이 있습니다.
• 외부 제품의 경우 * 을 제거해야합니다 (_i.e._ v*v' 구문).
• 외부 제품의 경우 새로운 기능을 사용해야합니다.
• 해당 중위 연산자는 구문을 가볍게 유지할 수 있습니다.

외부 제품에 대한 [간결한 수학적 구문]을 잃는 것은 불행한 일입니다. 나는 차라리 vec * mat를 개인적으로 포기하고 싶다.

기존 PernutedDimsArray가 부모와 뷰의 차원 수가 다른 경우를 이미 처리 할 수 ​​있습니까? 그렇다면 아마도 벡터 부모에 대해서도 비공 액 전치 래퍼 유형으로 이미 사용 가능할 것입니다.

설명서에서 PermutedDimsArray를 찾지 못했습니다.

하지만 더 많은 데이터 유형을 발명하는 대신
세 가지 유형의 어레이 제품 만 명확하게 구분해야합니다.
내부 제품은 이미 분리되어 있습니다.
일반 제품과 외부 제품 만 분리하면됩니다.
외부 제품은 손실되지 않고 구문 만 변경됩니다.
v*mx 케이스는 더 깊은 문제의 증상으로 만 고려하십시오.

"누락 된 메서드 문제"를 제외하고는 걱정할 유형이 아니라 .' 가 지연 래퍼 유형 (및 ' 반환하는 구현 세부 사항입니다. 이의 접합체 버전). 그렇지 않으면 동일한 * 연산자를 사용하여 vec*mat 및 vec*vec' 둘 다 가질 수 있다고 생각하지 않습니다. 논문에서 vec*mat 를 본다면 나에게는 틀린 것처럼 보이지만 vec*vec' 꽤 자주 봅니다.

그러나 그것에 대해 더 생각하면 PermutedDimsArray가 배열 배열에 대한 요소를 재귀 적으로 전치하지 않는다고 생각하므로 여기에서 사용하는 래퍼 유형으로 적합하지 않습니다.

다른 대안은 벡터 전치를 완전히 허용하지 않는 것입니다. 저는 여기에서 논의가 이미 지나치게 철저하다고 생각하며 영향이 어떻게 나타날지 평가하기 위해 하나 또는 두 가지 옵션의 포괄적 인 구현을 기다리고 있습니다.

이 스레드가 거의 끝나가는 동안 토론 할 준비가되어 주셔서 감사합니다.

v*mx 은 (는) 이상하게 보일 수 있지만 결정 학적 코드에서 많이 사용됩니다.
또한 Fortran의 matmul 에서도 잘 처리됩니다. (# 18056 참조)

u*v' 제품으로 돌아갑니다.
u 및 v 가 모두 nx1 행렬 인 경우 이것은 정규 행렬 곱입니다.
그것은 외부 제품과 동일한 결과를 제공하는 것으로 밝혀졌습니다.
그러나 이것은 매트릭스 제품을 사용하여 외부 제품을 모방하는 것입니다.
이것은 모든 것이 행렬 인 Matlab의 세계에서 매끄 럽습니다.

Julia에는 Fortran의 세계에 더 가까운 진정한 1 차원 벡터가 있습니다.
Julia에서 전치 된 벡터 v' 는 이미 문제입니다.
Fortran의 선택은 이미 다른 사람들이 Julia에게 제안한 것처럼이를 금지하는 것입니다.

Fortran에는 외부 제품에 대한 고유 기능이 없습니다.
Julia는 v' 를 1xn 행렬로 쉽게 변환합니다.
1d 벡터와 1xn 행렬에 대해 * 연산을 수행합니다.
다중 파견으로 인해이를 수행 할 수 있습니다.
하지만 여기서 * 는 더 이상 매트릭스 제품이 아닙니다.

Fortran과 Julia가 비슷하게 행동하는 지점
둘 다 내부 제품에 대해 별도의 dot 함수를 사용한다는 것입니다.
dot 을 * 연산자에도 묶는 토론이있었습니다.
하지만 운 좋게도 그렇게되지 않았습니다.

따라서 우리는 선형 대수의 세 가지 제품을 처리해야합니다.
일반 매트릭스 제품, 내부 제품 및 외부 제품.
현재 * 연산자는 일반 제품과 외부 제품에 대한 결합 구문입니다.
내가 제안한 것은 이들을 분리하고보다 일관된 상태에 도달하는 것입니다.

(오, 외적은 생략했지만 이미 잘 분리되어 있습니다)

내적, 외적, 행렬 곱셈이 제품을 나누고 분류하는 수학적으로 건전한 방법이라고 생각하지 않습니다. 다음은 여러 사람들이 위에서 언급 한 내용의 반복이지만,이 주제의 길이를 고려할 때 때때로 요약을 포함하는 것이 좋습니다. 이것은 내 개인 요약이며 나는 확실히 전문가가 아니므로 내가 틀린 부분을 수정하십시오.

추상 선형 대수 설정에서 주요 플레이어는 벡터 v (벡터 공간 V 거주), 선형 맵 (하나의 벡터 공간 V 및 다른 공간 W ) 및 이러한 맵의 구성, 선형 형태 또는 코 벡터 (이중 공간 V* 거주하고 V 에서 스칼라로 매핑), 내부 제품 ( V × V to scalars), 벡터 간의 텐서 곱 (예 : kron ). 외적 나는 벡터와 코 벡터 사이의 텐서 곱으로 생각하는 것을 선호합니다.

내적이 정의 된 경우이 문제에 대한 특별한 관심 벡터와 선형 형태의 동형 인 즉, 모든가 f 매핑 벡터 v 스칼라에, 거기에 존재하는 w f(v) = dot(w,v) 에 대해 v . 그러나 코 벡터는 내적 (예 : 다차원 함수의 기울기)에 대한 참조없이 존재할 수 있습니다.

컴퓨터에서 이러한 모든 개체를 표현하려면 일반적으로 기준을 선택한 다음 행렬 대수를 사용하여이 대부분을 나타낼 수 있습니다. 즉, 후행 단일 차원 (벡터를 nx1 행렬로, 스칼라를 1x1 행렬로 등)에 유연하게 적용하려는 경우에만 행렬 곱셈과 전치가 필요합니다. 이것은 Matlab이 취한 것이며, 특히 수치 선형 대수에서 많은 책과 논문이 작성되는 방식이었습니다.

이 경우, 앞서 언급 한 벡터에서 코 벡터로의 동형 (암묵적으로 유클리드 내적을 가정 함)은 벡터의 행렬 표현의 전치 (복잡한 경우 에르 미트 공액)를 취하는 것에 해당합니다. 그러나 추상적 인 의미에서 벡터의 전치 개념이 없기 때문에 @GaborOszlanyi가 언급 한 것처럼 Fortran에서 정의되지 않은 것

Julia 코드에서 형식 안정성이 중요하기 때문에 Matlab의 "유일한 행렬"(유연한 후행 단일 차원 사용) 접근 방식은 제대로 작동하지 않습니다. 그러나 우리는 또한 완전히 추상적 인 설정으로 전환하고 일반적인 설정에서 계속 작업하는 것을 원하지 않습니다 (Euclidean 내부 제품, 벡터에서 코 벡터로의 사소한 매핑 등). 결국 우리는 코드를 작성하고 ASCII 문자를 사용하기를 원하기 때문에 * , ' 및 .' 기호에서 가능한 한 많이 짜 내야합니다. 운 좋게도 여기에서 다중 디스패치가 편리하고 위에서 언급 한 다양한 제안으로 이어집니다. 나는 이것에 대한 표 를 만들었습니다. 즉, 추상적 인 선형 대수 연산이 함수가 아닌 특정 줄리아 방법으로 변환되는 방법입니다.

@GaborOszlanyi에 대한 마지막 메모로서, 나는 여전히이 모든 v*A 에 대한 장소를 찾을 수 없습니다. 이것은 벡터가 기본적으로 행 행렬로 표시되는 필드에서 표준 일 수 있지만 개인적으로 이것은 이상한 선택이라고 생각합니다. 선형 맵 f 및 g 가 f(v) = v*A 및 g(v) = v*B 을하는 경우 이는 g(f(v)) = (g ◦ f)(v) = v*A*B 로 구성 순서 이후에 홀수임을 의미합니다. 교환됩니다. 만약 있다면, 나는 이것을 링크 된 테이블의 두 번째에서 마지막 행과 같이 불완전한 내부 곱으로 해석 할 수 있습니다.

귀하의 요약은 깊고 설득력이 있습니다.
잘 설명 해주셔서 감사합니다.

남은 질문은 두 가지입니다.

• 이 철저한 논의의 결과로 Julia에서 실제로 어떤 변화가 일어날까요?
• Fortran이 v*mx 에 matmul v*mx 을 구현 한 이유는 무엇입니까?

이 문제로 인해 노출되는 두 가지 문제가 있습니다.

A. 응용 수학자들은 다음과 같은 두 가지 자연적인 동 형사상을 암묵적으로 사용하는 가정용 표기법에 결합됩니다.

1. 길이가 N 인 벡터는 Nx1 행렬이 벡터 공간을 형성하기 때문에 Nx1 _ 열 행렬 _과 구별 할 수 없습니다. ( "열", ▯)
2. 1x1 행렬은 스칼라의 모든 대수적 속성으로 정의 될 수 있기 때문에 스칼라 숫자와 구별 할 수 없습니다. ( "스칼라 화", ■)

문제는 이러한 동형이 Julia의 유형으로 표현하기에 자연스럽지 않으며 둘 다 배열 모양의 런타임 검사를 포함한다는 것입니다. MATLAB의 후행 싱글 톤 차원 규칙은 이러한 두 동형의 구현으로 생각할 수 있습니다.

B. 2 차원 배열은 배열의 배열로 재귀 적으로 정의 할 수 있습니다. 그러나 행렬은 열의 행 또는 행의 열이지만 행의 행이나 열의 열은 아닙니다. 행렬을 재귀 적으로 정의 할 수 없다는 사실은 행렬과 n 차원 배열의 다른 텐서 구조를 강조합니다. 적절하게 말하면 다차원 배열은 매우 제한된 종류의 텐서이며 후자를 구현하는 데 필요한 전체 기계가 부족합니다. 엄밀히 말하면 축소는 벡터 공간과 이중 벡터 공간의 쌍에 대한 작업이기 때문에 이중 벡터 공간의 개념을 절대 호출하지 않는 다차원 배열의 인덱스를 축소하는 것에 대해 말하는 것은 잘못된 이름입니다. 대부분의 사람들은 전체 기계를 원하지 _ 않습니다 _. 이는 행 / 열 특성을 가진 공 / 반 변성 또는 업 / 다운 인덱스에 대해 걱정해야합니다. 대신 대부분의 사람들은 배열이 모든 차원에서 완전히 반변적인 일반 컨테이너가되기를 원합니다. _2 차원을 제외하고 _ 대부분의 사용자는 2 차원 배열을 행렬의 대수 (하향 텐서)를 갖는 것으로 생각하고 결코 다운-다운, 업-업 또는 업-다운 텐서. 즉, 2 차원 배열은 특수한 경우를 원합니다.

나는 여전히 다른 방법으로 설득 될 수 있지만, 현재 3 부로 구성된 제안이 있습니다.

a) 벡터 전치 금지, u'v , u*v' , u'*A*v 및 u'*A*v/u'v 와 같은 가정부 스타일 표현식을 작성하기 위해 사용자가 벡터를 열 행렬로 명시 적으로 변환해야합니다 u*v' u'*A*v/u'v . 이러한 모든 표현식은 matmul, 행렬 전치 및 행렬 나누기의 세 가지 기본 단항 및 이항 연산자로 만들 수 있습니다. 반대로, u 및 v 가 트루 벡터 인 경우 u' 또는 u'*A 와 같은 하위 표현식에 특별한 TransposedVector 도입하지 않고 의미를 부여 할 수 없습니다

(a)의 한계는 모든 가정부 스타일 표현식이 실제 스칼라 대신 1x1 행렬을 생성한다는 것입니다 (이는 여전히 1- 벡터를 반환하는 u'v 보다 크게 향상됨). 따라서 (u'*v)*w 와 같은 표현식

b) 벡터에 대한 유사 연산에 대한 대체 표기법을 도입하십시오.

• 내부 (점) 제품의 경우 u ⋅ v = scalarize(columnify(u)'*columnify(v))
• 외부 (Kronecker) 제품의 경우 u ⊗ v = columnify(u)*columnify(v)'
• A(u, v) = scalarize(columnify(u)'*A*columnify(v)) , 쌍 선형 형식에 대한 오래된 표기법
• 2 차 형식의 경우 A(u) = A(u, u)

(b)의 식은 내적 및 쌍 선형 / 2 차 형식에 대한 식을 자동으로 스칼라 화하여 1x1 행렬의 형성을 피함으로써 (a)의 식과 다릅니다.

c) 1x1 행렬을 트루 스칼라로 변환 가능하게 만들어 다음과 같은 코드를 만듭니다.

M = Array(Int, 1, 1, 1)
a::Int = M

작동 할 수 있습니다. 필요한 것은 다음과 같이 어레이 크기에 대한 런타임 검사를 수행하는 것입니다.

function convert{T}(::Type{T}, A::Array{T,N})
    if length(A) == 1
        return A[1]
    else
        error()
    end
end

이 제안은 약 2 년 전에 Folkmar Bornemann이 제안한 것을 약간 수정 한 것입니다. 우리가 그것을 시도했을 때, 런타임 검사의 비용은 그리 크지 않았고, 일반적인 할당이 아니라 유형 강제 할당 (실제로는 convert 호출)에서만 호출됩니다.

@jiahao ,이 게시물의 가독성은 렌더링하기 어려운 문자에 의해 제한됩니다. 일반적으로 글꼴에 완전히 유니 코드가있는 OS X에서는 제대로 보이지 않습니다.

@jiahao , 두 가지 사항에 도전하고 싶지만 대부분 / 모두 동의 할 수 있습니다.

특별한 TransposedVector 유형을 도입하지 않고, 논리적 결과로 다차원 배열이 텐서 구조의 업 / 다운 인덱스에 대해 걱정해야하는데, 이는 지불하기에 너무 높은 가격처럼 보입니다.

이것은 TransposedVector AbstractArray 계층 구조의 하위 유형으로 만들고자하는 경우에만 논리적 결과로 보입니다 (실제로 LazyTranspose 유형과 달리 AbstractMatrix 의 또 다른 종류입니다).

외부 (Kronecker) 제품의 경우 u ⊗ v

목표가 암시 적 동형에 의존하지 않고 벡터 연산과 더 추상적 인 제품에서 행렬 연산을 명확하게 분리하는 것이라면 다음과 같은 이유로 실패한다고 생각합니다 (다음 수학적 정의에 대한 보편적 인 합의에 대해 확신 할 수 없습니다).

• Kronecker 제품 A ⊗ B 는 벡터가 아니라 행렬에 정의 된 연산입니다.
• 따라서 u ⊗ v 를 두 벡터의 텐서 곱으로 읽는 대신 아래로 다운 유형의 2 차원 텐서를 생성합니다. 적절한 '행렬'을 얻는 유일한 방법은 벡터의 텐서 곱을 코 벡터로 가져 오는 것입니다. 그러나 이러한 객체의 도입을 피하고 싶기 때문에 관련된 두 벡터를 열화하기 전에이 작업의 결과를 얻는 것이 불가능한 것 같습니다.
• u ⊗ v 의 세 번째 이름은 일반적으로 엉성하게 정의 된 외부 제품이며, 위아래로 허용되는 엄격한 정의가 있는지 확실하지 않습니다. 일부 출처는 두 벡터의 텐서 곱과 동일하므로 이전 점을 언급합니다. 대신 '외부 곱'이 암시 적으로 두 번째 벡터를 코 벡터에 매핑하여 다운 업 텐서를 얻는 것을 의미하는 정의를 수락하면 문제가 없습니다.

대신 대부분의 사람들은 배열이 2 차원을 제외하고 모든 차원에서 완전히 반변적인 일반 오래된 컨테이너가되기를 원합니다.

핵 옵션을 고려 했습니까? 선형 대수학을 시작하여 AbstractVector 및 AbstractMatrix 대한 typealias를 완전히 제거하고 다음으로 대체합니다.

abstract AbstractVector{T} <: AbstractArray{T,1}
abstract AbstractMatrix{T} <: AbstractArray{T,2}

# and we could introduce:
abstract AbstractCoVector{T} <: AbstractArray{T,1}

많은 낙진이 있다는 것을 이해하지만 다차원 저장 배열과 선형 대수를 깔끔하게 분리 할 수 ​​있습니다. 우리는 완전한 다차원 텐서 대수, 이중 벡터 공간 등을 구현할 필요가 없습니다. 우리는 많은 사람들이 원하는 비트, 즉 벡터, 코 벡터 및 행렬을 구현하기 만하면됩니다. 우리는 내적, 외적, covector-matrix product, matrix-vector product 및 matrix-matrix product를 얻습니다. Transpose는 위의 모든 항목에 정의되어 있습니다. 우리는 실제로 1D 배열의 1D 배열을 사용하는 AbstractMatrix 구현을 가질 수 있습니다 (물론 기본 구현이 아닙니다). 가정용 표기법 (IMHO는 MATLAB의 약점 중 하나입니다!)을 사용할 필요는 없지만 선형 대수의 모든 편리함을 얻을 수 있습니다.

나는 이것을 제안하는 것이 약간 긴장되지만, Julia는 대부분의 사람들이 예를 들어 1 학년 대학 수준의 선형 대수에서 배운 것의 "올바른"모델을 모방 할 수있을 것이라고 믿습니다. 명확하게 구분하면 Base.LinAlg 를 "표준 라이브러리"패키지로 쉽게 이동할 수 있습니다.이 패키지는 Julia에게 장기적인 목표라고 생각합니다. 또한 새로운 Buffer 변경 사항 및 Array 의 기본 구현과 함께 제공되는 새로운 1D 크기 조정 가능 목록과 같은 것이있을 것이라는 생각과 잘 맞습니다. 따라서이 일반적인 "목록"유형 Julia의 많은 핵심 부분에 대해 Vector 를 대체 할 수 있으며 Array 및 "list"를 아주 일찍 정의하는 동안 LinAlg 패키지를 아주 늦게로드 할 수 있습니다.

이미 "단순"된 많은 알고리즘이 있으며 적절한 선형 대수가 아닌 포트란 배열로 표현됩니다. Julia는 사람들이 다차원 배열 위에서 선형 대수 구조를 재발견 (또는 강제)하지 않고도 이러한 알고리즘을 구현할 수 있어야합니다.

내 작업 라인에서 텐서 및 공 / 반 변성 인덱스 등을 Fortran 배열에 매핑하는 적절한 선형 대수가 아마도 가장 좋습니다. 이 작업을 수행하고 사람들을 혼동하지 않기 위해 "벡터"와 "행렬"및 "배열"이라는 용어는 그대로두고 낮은 수준으로 유지하고 모든 높은 수준에 대해 다른 (더 멋진?) 용어를 사용합니다. . 더 높은 수준은 추상 유형 또는 매개 변수화를 통해 저장 옵션을 추상화해야합니다. 아마도 접두사 LA 가 이것을 표현하는 방법 일 것입니다 :

LA.Vector
LA.CoVector
LA.Tensor{... describing co/contravariance of indices ...}

그런 다음 벡터와 행렬은 순수하게 저장에 사용됩니다. 낮은 수준에서 조옮김은 수동으로 관리됩니다 (BLAS에서와 동일). 높은 수준에서는 자동으로 처리됩니다.

이것은 이전 버전과의 호환성을 깨지 않고 Matlab / Fortran / numpy 변환 자의 기대를 깨지 않는다는 점을 제외하면 @andyferris 의 제안에 가깝습니다.

@eschnett 이 스레드의 앞부분에서 다중 선형 대수학이 기본 Julia가 아닌 패키지에 남겨질 것이라고 결정했다고 생각합니다. 나는 당신이 제안한 것과 같은 많은 아이디어가 편의 기능을 제공하는 _TensorOperations.jl_ 패키지와는 다소 다른 유형 시스템 내에서 텐서, 벡터 공간, 공 / 대변 량 등을 처리하는 새로운 패키지로 구체화 될 수 있다고 생각합니다. 배열을 텐서처럼 곱하기 위해. 개발하기는 어렵지만 잠재적으로 가치있는 추상화라고 생각합니다!

Matrix 및 Vector 만 남겨 두는 경우-현재 정의가 완벽하거나 표준 수학을 사용하여 행렬을 곱하고 벡터를 전치하려는 사람들을 위해 더 나은 조치가있을 수 있습니다. 표기법. 나는 그것이 새로운 사용자에게 작은 학습 곡선을 추가 할 수 있다고 생각하지만, 시스템이 분명하고 유창하고 다른 언어에서는 _ 개선 _된다면 배우기 쉬울 것입니다.

일반적인 비 유클리드 복합 벡터 공간 V 에는 V , conj(V) , dual(V) 및 conj(dual(V)) 개의 연관된 공간이 있습니다. 따라서 일반 텐서에는 4 가지 종류의 인덱스가 있습니다 (일반적으로 up 또는 down, barred 또는 not barred로 표시됨). 복잡한 유클리드 공간 (예 : 양자 역학)에서 dual(V) ≡ conj(V) 및 conj(dual(V)) = V . 실제 (비 유클리드) 공간 (예 : 일반 상대성 이론)에서 V ≡ conj(V) . 후자의 경우 모두 업 및 다운 인덱스 만 필요합니다.

실제 유클리드 공간 (대부분의 응용 프로그램?)에서는 모두 동일하며 julia의 일반 배열은 텐서를 나타내는 데 충분합니다. 따라서 적어도 실수의 경우 다음 두 연산을 통해 완전하고 일관된 텐서 대수를 구성 할 수 있습니다.

• contract / inner product ∙ , 다음 규칙을 사용하여 N 순위의 임의 배열로 일반화 할 수 있습니다. 첫 번째 배열의 마지막 인덱스를 두 번째 인덱스 (또는 numpy의 dot 규칙, 비록 덜 직관적이라고 생각합니다), A 및 B 에 순위가 M 경우 A A ∙ B 는 순위 배열 M+N-2 반환합니다. M 및 순위 N .
• tensor product ⊗ : A ⊗ B 는 순위 배열을 반환합니다. N+M

벡터 v , w 및 행렬 A , B 로 특수화되어 다음을 모두 작성할 수 있습니다.

• 벡터 내적 v ∙ w -> 예외적으로 순위 0 배열 대신 스칼라를 반환합니다.
• 행렬 벡터 곱셈 A ∙ v
• 행렬 행렬 곱셈 A ∙ B
• 텐서 / 외부 제품 v ⊗ w
• 코 벡터 (=== 벡터) 행렬 곱셈 v ∙ A

하나를 사용할 수도 있지만 * 에 대해 ∙ , 함정은의 위의 정의이다 ∙ 연관되지 않습니다 : (A ∙ v) ∙ w ≠ A ∙ (v ∙ w) 후자 심지어 않을 것 정의됩니다.

그러나 다시 말하지만 복잡한 배열을 무시하려는 경우에만 해당됩니다.

텐서의 완전히 일반적인 구현에 관해서는 스택 할당 튜플, 생성 된 함수 및 오늘날 더 실현 가능하게 만들 다른 모든 좋은 기능이 있기 전에 오래 전에 이것을 시작했습니다 (그리고 포기했습니다).

흥미로운 접근 방식, @Jutho. 충분히 직관적 인 것 같습니다. 저는 * 및 ' 로 무엇을하는지에 관계없이 이러한 정의가 추가 될 수 있다고 _ 추측합니다 _. 그리고 저는이를 지원할 것입니다.

그러나 다시 말하지만 복잡한 배열을 무시하려는 경우에만 해당됩니다.

수동으로 삽입 된 conj() 해결합니다. 그리고 Julia가 복잡한 행렬을 무시하고 싶어한다고 생각하지 않습니까?

유형 별칭이 아닌 특수 하위 유형으로 AbstractMatrix 를 사용하는 것에 대해 몇 가지 더 알아 차 렸습니다.

matrix[:,i] -> AbstractVector{T}
matrix[i,:] -> AbstractCoVector{T}
array_2d[:,i] -> AbstractArray{T,1}
array_2d[i,:] -> AbstractArray{T,1}

이것은 매우 멋집니다. 행렬을 인덱싱하여 열과 행 벡터를 얻을 수 있습니다. 2D 스토리지 컨테이너 인 경우 1D 스토리지 어레이가 제공됩니다. 모든 사용 사례를 다루어야합니다! 그리고 AbstractVector{T} <: AbstractArray{T,1} 및 AbstractCoVector{T} <: AbstractArray{T,1} 이므로 APL 슬라이싱 규칙을 사용하는 AbstractArray 인터페이스를 여전히 준수합니다.

하나의 "흥미로운"사실은

array_3d[:,:,i] -> AbstractArray{T,2}
matrix(array_3d[:,:,i]) ->`AbstractMatrix {T}

따라서 결과로 행렬 곱셈을 수행하려면 수동으로 행렬로 래핑해야합니다. 이게 플러스인지 마이너스인지 모르겠어요? 그러나 이것은 하나의 잠재적 인 복잡성으로 보이며 저장소와 선형 대수를 결합하는 다른 언어의 사용자가 쉽게 사용할 수 있도록

이것은 어리석은 질문 일 수 있지만, @jutho 는 코드 작성이 ASCII에 의해 제한

우리는 유니 코드를 사용할 수 있습니다. 불행히도 키보드의 크기는 지난 40 년 동안 비슷한 요인으로 커지지 않았고, 평범한 사람이 가지고있는 손가락의 수도 (지난 1 만년 이상) 아쉽게도 성장하지 않았습니다.

IMHO, ASCII는 쉬어야합니다. 빠른 수학 기호 프로그래밍을위한 특수 수학 키보드는 실제로 좋은 생각입니다! UTF와 함께 제공되는 더 많은 기호를 사용하지 않는 좋은 이유가 있습니까? 가능한 모든 것을 ASCII에서 추출하려는 노력의 고통을 정당화 할 수 있습니까?

@ esd100 :이 GitHub 문제를 매우 투기적인 토론에 사용하지 마십시오.

트윗 담아 가기 "투기 적"이 무슨 뜻인지 잘 모르겠습니다. 당신이 사용하려는 단어가 확실합니까? 언어, 연산자 및 기능이 사용 된 기호에 묶여있는 것처럼 보이기 때문에 ASCII 대 다른 것의 사용이 토론과 관련이 있다고 생각했습니다. 나는 어떤 식 으로든 전문가는 아니지만 해결되는 기능과 관련하여 논의하거나 적어도 명확하게 밝히는 데 문제가있는 것 같습니다.

우리가 원하는 방식으로 언어를 정의 할 수없는 이유가 있습니까 (기본 목표 : 사용 용이성, 속도)? 특별한 기호 / 단어를 사용하면 언어가 더 풍부하고 아름답 지 않을까요?

@ esd100 예를 들어 @Jutho 의 가장 최근 댓글 (유니 코드 기호 2 개 사용)이 호평을 받았으며 @yuyichao 는 유니 코드를 사용할 수 있다는 데 동의합니다. 더 많은 유니 코드 전용 연산자를 도입하기위한 다른 제안이 있습니다 (예 : 함수를 구성하는 compose 기호, # 17184). 사람들이 귀하에게 동의하지 않는다고 생각하지 않습니다 (실제적인 고려 사항이 있음을 염두에 두어야 함). _ 특정 _ 주제에 대한 제안이있는 경우 알려 주시기 바랍니다.

이 토론에서 발생한 v0.5 새로운 동작에 대해 약간 혼란 스럽습니다.

julia> [ x for x in 1:4 ]' # this is fine
1×4 Array{Int64,2}:
 1  2  3  4

julia> [ Symbol(x) for x in 1:4 ]' # bit this isn't? What is special about symbols?
WARNING: the no-op `transpose` fallback is deprecated, and no more specific
`transpose` method for Symbol exists. Consider `permutedims(x, [2, 1])` or writing
a specific `transpose(x::Symbol)` method if appropriate.

목록 이해에서 (숫자가 아닌) 행 벡터를 만들려면 어떻게해야합니까? 행 벡터 여야합니다. (별도의 문제로 더 좋을까요, 아니면 다른 곳에서 논의할까요? 어디에 게시해야할지 모르겠습니다 ...)

모양 변경 : reshape(v, 1, length(v)) 사용할 수 있습니다. 지원 중단 경고에도 언급되어야할까요? 이 아이디어는 전치가 수학적 연산이므로 수학적 벡터 / 행렬에 대해서만 정의되어야한다고 생각합니다.

depwarn : permutedims(x, [2, 1]) 언급되어 있습니다.

permutedims 는 벡터에서 작동하지 않습니다. 새로운 호보기 : # 18320

이 아이디어는 전치가 수학적 연산이므로 수학적 벡터 / 행렬에 대해서만 정의되어야한다고 생각합니다.

이것은 나에게 의미가 없습니다. 토론할까요? 정말 좋은 정당성이 없다면 숫자가 아닌 배열에서 작업하기 위해 전치하는 것을 정말로 선호합니다.

이 아이디어는 전치가 수학적 연산이므로 수학적 벡터 / 행렬에 대해서만 정의되어야한다고 생각합니다.

이것은 나에게 의미가 없습니다. 토론할까요? 정말 좋은 정당성이 없다면 숫자가 아닌 배열에서 작업하기 위해 전치하는 것을 정말로 선호합니다.

나는 당신이 원하는 것을 만족시키는 것은 비교적 복잡하다고 생각합니다. 수학적 의미에서 전치는 종종 벡터 공간과 벡터 또는 행렬의 이중 공간을 교체하여 정의됩니다 (전치 대 켤레 전치에도 약간의 복잡성이 있습니다). 정규 숫자의 행렬 M 의 경우, 우리는 permutedims(M, (2,1)) 로 전치하지만 일반적으로 다음과 같은 부분 행렬의 관점에서 "블록"행렬을 정의 할 수 있습니다.

M = [A B;
     C D]

여기서 A 등은 행렬 자체입니다. 내 이해는 Julia가

M' = [A' C';
      B' D']

이것은 펜과 종이로 된 수학을 사용하여 할 것이므로 "바람직한 구문"입니다.

즉, 행렬의 요소는 ' 및 .' 합니다. 숫자의 경우 이들은 각각 복합 활용 및 무 작업으로 정의됩니다. IMHO 저는 이것이 편리함의 말장난이라고 생각하지만, 작동하고 가장 중요한 것은 _simple_ 규칙으로 구현된다는 것입니다 ( "transpose is recursive"- BlockMatrix 클래스 등이 필요하지 않음). 하지만이 말장난은 0.5에서 숫자가 아닌 유형에서 제거되었습니다.별로 말이되지 않기 때문입니다. Symbol 의 조옮김은 무엇입니까?

숫자가 아니라 _data_를 사용하는 경우 permutedims 은 그 의미와 동작이 완벽하게 잘 정의되어 있습니다. 비재 귀적입니다. .' 와 같은 수학적 말장난을 사용하면 입력하는 문자 몇 개를 절약 할 수 있습니다.하지만 다른 사람 (수학이나 MATLAB에 익숙하지 않은 사람)이 사용중인 경우 코드를 읽는 것이 _lot_ 더 합리적입니다. reshape 및 permutedims . _ 나에게 이것이 가장 _

IMHO이 매우 긴 문제는 선형 대수를 위해 수학적으로 일관된 인터페이스를 만드는 것에 관한 것이며 결과가 데이터 배열에 대한 수학적 말장난이 적다는 것은 당연한 것 같습니다.

사려 깊은 답변에 감사드립니다. 나는 여전히 상당히 동의하지 않는다

하지만이 말장난은 0.5에서 숫자가 아닌 유형에서 제거되었습니다.별로 말이되지 않기 때문입니다. 기호의 전치가 무엇입니까?

Symbol 의 전치를 no-op으로 정의하는 것이 실수로 전치를 정의하는 것보다 덜 의미가 있는지 잘 모르겠습니다. 나는 "말장난"이 편리하다는 것을 알지만, "적절한"일은 벡터와 행렬에 대해서만 정의하고 transpose(A::Matrix{Complex}) conj 의 일부로 적용하는 것입니다. 그 실행.

.' 와 같은 수학적 말장난을 사용하면 입력하는 문자 몇 개를 절약 할 수 있습니다.하지만 다른 사람 (수학이나 MATLAB에 익숙하지 않을 수 있음)이 사용중인 경우 코드를 읽는 것이 훨씬 더 합리적입니다. 필요에 따라 모양을 변경하고 순열합니다. 제게는 이것이 가장 중요한 포인트입니다.

본인은 .' 이 신중하게 사용되어야하며 transpose 대한보다 명확한 호출이 종종 더 낫다는 데 동의합니다. reshape 및 permutedims 는 처음부터 읽고 코딩하는 데 사소한 양의인지 오버 헤드가 필요할 수 있다고 생각합니다. 파싱하는 것이 더 빠릅니다.

transpose([ f(x) for x = 1:length(A) ])
reshape([ f(x) for x = 1:length(A) ], 1, length(A))

이와 같은 간단한 경우에도 무슨 일이 일어나고 있는지 이해하려면 줄의 시작 부분에서 끝까지 ( reshape 를 읽음) 끝까지 튕겨 야합니다 ( length(A) 를 읽음). (그런 다음 처음에 length(A) 이 (가)있는 이유를 이해하기 위해 중간으로 돌아갈 수 있습니다.)

나에게 더 큰 문제는 내가 새로운 Julia (이전에 numpy와 MATLAB을 사용했을 가능성이 있음)이고 이것이 작동한다는 것을 알 수 있다는 것입니다.

[ x for x = 1:10 ]'

나는 당연히 문자열, 기호 등의 배열에 대해서도 같은 것이 작동한다고 가정 할 것입니다. .' 의 의미를 파악하기 위해 긴 온라인 토론을 읽지는 않을 것입니다. 몇 가지를 시도하고 과거의 경험으로 일반화 / 추론 할 것입니다. 더 나은 오류 메시지가 여기에 도움이 될 것입니다.

전반적으로 Symbol 및 기타 비 숫자 입력에 대한 no-op 조옮김을 유지하는 것이 여기서 제안 된 멋진 수학적 프레임 워크 (가치있는 목표!)를 방해하는 방식을 알지 못합니다. 그러나 노옵을 유지하는 것은 무해한 것 같습니다.

그러나 노옵을 유지하는 것은 무해한 것 같습니다.

모든 것이 Any 의 하위 유형이기 때문에 Any 대해 의미있는 어떤 것도 정의 할 수 없습니다. transpose(x)=x 정의는 모든 종류의 행렬에 대해 명백히 잘못되었으며 이러한 정의 를 추가해야하는 일부 조용한 오류를 방지하기 위해 있습니다. 따라서 완전히 비 수학적 작업에 대해 상대적으로 이상한 구문 ' 를 허용하고 자동 오류를 방지하는 편의성 사이의 절충점입니다.

기호의 조옮김을 no-op으로 정의하는 것이 실수로 조옮김을 정의하는 것보다 덜 의미가 있는지 잘 모르겠습니다. 나는 "말장난"이 편리하다는 것을 알지만, "적절한"일은 벡터와 행렬에 대해서만 정의하고 transpose(A::Matrix{Complex}) conj 의 일부로 적용하는 것입니다. 그것의 실행.

나는 완전히 동의하지 않지만 BlockMatrix 같은 것을 구현하거나 Matrix{M<:Matrix} 대해 정의 된 특수 메서드를 가져야합니다. 둘 중 하나가 인기있는 아이디어인지 아닌지 잘 모르겠습니다. (이것은 이러한 관련 문제 중 일부를 단순화 할 수 있기 때문에 팔로우 한 사람들에게 심각한 질문입니다).

파싱하는 것이 더 빠릅니다.

transpose([ f(x) for x = 1:length(A) ])
reshape([ f(x) for x = 1:length(A) ], 1, length(A))

두 번째는, 나는 벡터의 줄리아의 현재 전위처럼 / 관련되지 않기 때문에 (분명히 _i 걸릴 벡터 transposes_ 너무 _seriously_ :)) 내가 자세하게 작성합니다 두 번째해야 할 일을했을 경우 rowvec = reshape(colvec, (1, n)) , 또는 아마 [f(x) for _ = 1:1, x = 1:n] 는 이해력이 올바른 모양을 만들도록 강제하거나 .' 를 정말로 좋아한다면 map(f, (1:n).') 와 f.((1:n).') 현재 작동합니다.

완전히 비 수학적 연산에 대해 상대적으로 이상한 구문을 허용하는 것과 자동 오류를 방지하는 편의성 사이의 절충점입니다.

이것이 침묵의 오류 및 기타 문제를 일으킨다면 아마도이 논쟁을 잃을 것입니다. (왜 오류가 발생하는지 모르겠지만 나는 당신을 믿습니다.) 반면에 ....

일종의 BlockMatrix를 구현하거나 Matrix {M <: Matrix}에 대해 정의 된 특수 메서드가 필요합니다.

내가 틀렸을 수도 있지만 두 번째 작업을해야한다고 생각하는데, 이는 나에게 합리적인 선택 인 것 같습니다. 그러나 이것은 내 월급을 넘어 서기 시작했습니다.

[f (x) for _ = 1 : 1, x = 1 : n]

나는 이것을 잊었다! 이것은 아마도 내가하게 될 것입니다. 전반적으로, 나는 여전히 읽을 수있는 코드에 대한 당신의 취향에 동의하지 않지만, 각각 자신의 취향에 동의합니다! ¯\_(ツ)_/¯

분명히 벡터 전치를 너무 심각하게 받아들입니다

예. 나도 그렇게 생각해. 😉

이것은 (https://github.com/JuliaLang/julia/issues/16790) 또한 transpose 대신 reshape 를 사용하여 나에게 약간 더 맛있게 만들 것입니다.

내가 틀렸을 수도 있지만 두 번째 작업 만 수행하면된다고 생각합니다 (편집 : Matrix{M<:Matrix} 대해 정의 된 특수 조옮김 메서드 포함). 이것은 나에게 합리적인 옵션처럼 보입니다.

불행히도 이제 우리는 다시 데이터와 선형 대수 사이의 구분으로 돌아갑니다. 선형 대수 블록 행렬에는 재귀 전치가 있지만 2D 데이터 배열의 일반 2D 데이터 배열에는 재귀 전치가 없기를 원 하지만 Matrix{T} 및 Array{T,2} 은 (는) 불가능합니다. 그렇게.

이것은 (# 16790) 또한 나에게 약간 더 입맛에 맞게 조옮김 대신에 모양 변경을 사용하게 만들 것입니다.

진실!!

선형 대수 블록 행렬에는 재귀 전치가 있지만 2D 데이터 배열의 일반 2D 데이터 배열에는 재귀 전치가 없습니다.

이건 내가 당연히 원하는 것 같지 않은데 ... 왜 이렇게 서로 다른 종류의 전치를 처리하기 위해 두 가지 다른 기능을 가지고 있지 않습니까? 선형 대수 객체와 데이터 객체 사이에 매우 엄격한 구분이 있다는 메모를 놓친 것 같습니다.

이 전체 스레드를 읽는 것은 벅찬 작업처럼 보이지만 추가로 설명하기 전에 그렇게해야합니다. 알지 못하는 소음을 추가하고 싶지 않습니다.

선형 대수 객체와 데이터 객체 사이에 매우 엄격한 구분이 있다는 메모를 놓친 것 같습니다.

Linear Algebra 개체와 Data 개체 간에는 엄격한 구분이 없습니다.
현재 구현도 아니고 이상적인 사용도 아닙니다.

있는 경우 크기 ( push! ) 또는 Linear Algebra 개체의 값을 수정하는 것은 지원되지 않으며 (이러한 사용자는 StaticArrays.jl 등을 사용합니다) broadcast 만 선형 대수 객체에서 지원됩니다.
데이터 객체는 수정 및 확장 가능하며 map , (및 reduce 및 filter )를 지원하지만 broadcast 하지 않습니다.

그러나 우리 는 사람들이 데이터 객체와 선형 대수 객체의 바이너리를 생각하는 세상에 살지
따라서 이번 2.5 년, 340 개의 댓글 스레드.

no-op 전치입니다.
우리는 Scalar 및 Nonscalar 추상 유형을 매우 높은 유형 계층 구조에 추가 할 수 있습니다.
Scalars 모두 no-op 조옮김으로 대체합니다.
Nonscalars 이 없지만 지금은 지원 중단 경고로 대체합니다.

숫자, 문자, 문자열, 심지어 튜플도 Scalar 이고 no-op transpose가 정의되어 있습니다. 일부 스칼라, 예를 들어 복소수는이 전치 정의를 덮어 씁니다.

배열 (행렬, 벡터 및 기타)은 Nonscalar 하위 유형이며 재귀 전치가 있습니다.

내가 그것을 좋아하는지 아닌지 잘 모르겠습니다.

최근 많은 게시물이 # 18320 # 13171 # 13157 # 8974의 _matrix transpose_ 및 "scalar"유형에 대한 토론을 다시 작성합니다.

transpose(x)=x no-op 폴 백이 무해하다는 개념을 정말로 없애고 싶습니다. 제 생각에, 폴백은 최적화 된 알고리즘보다 더 느리게 올바른 결과를 생성해야합니다. fallback 메소드가 자동으로 잘못된 답을 계산하는 것은 위험합니다. 이는 fallback이 올바른 의미를 가지고 있지 않다는 것을 의미하기 때문입니다. transpose(x) 는 x 유형에 따라 다른 것을 의미합니다.

no-op 전치 폴백은 행렬의 행렬에 대해 잘못 될뿐만 아니라 AbstractMatrix 하위 유형이 아닌 모든 행렬 유사 객체에 대해 잘못되었습니다 (# 987에 의해 명시 적으로 저장된 항목이 있음을 의미합니다. _not_ 행렬의 대수를 가지고 있음). 다음은 하나의 포스터 자식 예제입니다 (많은 수가 있습니다).

julia> A = rand(5,5); F = qrfact(A); R = F[:R]; Q = F[:Q] #Q is an example of a matrix-like object
5x5 Base.LinAlg.QRCompactWYQ{Float64,Array{Float64,2}}:
 -0.518817    0.0315127   0.749223    0.410014  -0.0197446
 -0.613422   -0.16763    -0.609716    0.33472   -0.3344   
 -0.0675866   0.686142    0.0724006  -0.302066  -0.654336 
 -0.582362   -0.0570904   0.010695   -0.735632   0.341065 
 -0.104062    0.704881   -0.248103    0.295724   0.585923 

julia> norm(A - Q*R) #Check an identity of the QR factorization
8.576118402884728e-16

julia> norm(Q'A - R) #Q'A is actually an Ac_mul_B in disguise
8.516860792899701e-16

julia> Base.ctranspose(Q::Base.LinAlg.QRCompactWYQ)=Q; #Reintroduce no-op fallback

julia> norm(ctranspose(Q)*A - R) #silently wrong 
4.554067975428161

이 예제는 무언가가 Any 의 하위 유형이라고해서 그것이 스칼라라고 가정 할 수 있고 no-op 전치가 있다는 것을 의미하지는 않습니다. 또한 OP의 상위 문제가 해결하기 어려운 이유를 보여줍니다. 행렬과 같은 비 배열 객체 Q의 경우 Q' 는 배열 연산으로서 실제 의미가 없지만 명확한 대수적 의미를 갖습니다. Q'A 와 같은 표현식은 완벽하게 잘 정의되어 있습니다. 선형 대수가 아닌 배열로 작업하는 다른 사람들은 단순히 비재 귀적 순열을 원하고 행렬과 같은 비 배열은 신경 쓰지 않습니다. 그럼에도 불구하고 모든 유형에 대해 대수 및 축 교환 의미론 모두에 대해 일관된 철자를 가질 수 없다는 사실이 남아 있습니다.

아마도 나는 밀도가 높지만 비교가 다음과 같을 것이라고 생각했을 것입니다.

julia> A = rand(5,5); F = qrfact(A); R = F[:R]; Q = F[:Q]
julia> Base.ctranspose(Q::Any) = Q;
WARNING: Method definition ctranspose(Any) in module Base at operators.jl:300 overwritten in module Main at REPL[6]:1.
julia> norm(ctranspose(Q)*A - R) # still works fine
4.369698239720409e-16

이런 식으로 transpose 를 덮어 쓰면 transpose([ :x _=1:4 ]) -즉 내가 게시 한 내용이 허용되는 것 같습니다. 필요한 모든 것에 대해 transpose / ctranspose 올바르게 구현하는 한 (예 : QRCompactWYQ ) 폴 백이 호출되지 않을 것이라고 생각했을 것입니다. 만들 수 있습니다).

코드가 작성한 ctranspose 메서드를 호출하지 않습니다 ( @which ). 본질적으로 ctranspose(full(Q)) 수행하는 Julia v0.5 (v0.4에는 존재하지 않음)에서 다른 대체 메서드를 호출하고 있습니다. 이 다른 폴백은 맞지만 우리가이 멋진 Q- 타입을 가지고있는 바로 그 이유를 무너 뜨립니다 (그래야 곱셈을 정확하게 할 수 있습니다). 폴 백이 정확해야한다는 내 의견은 여전히 ​​유효합니다.

예, 모든 항목에 대해 올바르게 조옮김을 구현하는 한
당연히 폴백은 해를 끼치 지 않습니다. 해악은 당신이
그것을 잊은 경우 방법 없음 오류가 발생하지만 조용히 잘못되었습니다.
결과.

나를 위해 클릭하게 만든 @toivoh 에게 감사드립니다. 설명 해주셔서 감사합니다.

그러나 대체 transpose(X::AbstractMatrix) 및 transpose(X::AbstractVector) 함수를 정의하면 아마도 항상 올바른 결과를 얻을 수 있습니다 (느린 경우에도 ... 예를 들어 full 호출). 더 나은 / 빠른 작업을 위해 항상 더 전문화 된 함수를 작성할 수 있습니다. 그러면 transpose(::Any) 가 앞서 언급 한 "말장난"이외의 다른 오류를 일으키지 않아야합니다 (즉, Complex 번호를 처리 할 때 ... 내가 모르는 다른 스칼라 사용 사례일까요?).

역사적인 이유로 QRCompactWYQ <: AbstractMatrix 이지만 # 987 # 10064에 따르면이 하위 유형 관계는 올바르지 않으므로 제거해야합니다.

행렬과 같은 비 배열의 또 다른 예는 IterativeSolvers.AbstractMatrixFcn 이며, 이는 AbstractMatrix 의 하위 유형이 아닙니다. 이 유형의 경우 참조하는 폴백은 절대로 전달되지 않으며 다시는 내 요점이었습니다.

https://github.com/JuliaLang/julia/issues/13171 에서이 토론을 계속해야합니다

"팀 선형 대수학"의 누군가가 한 단계 올라서 0.6을 위해 뭔가를해야합니다. 그렇지 않으면 다시 부딪 힐 것입니다.

재부팅하려면 실제 계획은 무엇입니까?

제 생각은 다음과 같습니다. transpose(v::AbstractVector) = TransposedVector(v) 여기서 TransposedVector <: AbstractVector . TransposedVector 와 AbstractVector 를 구별하는 유일한 의미는 * (및 모든 A_mul_B s, \ , / , ...). 즉, * (etc ...) 미만으로 계약 할 인덱스를 결정하는 데코레이터입니다. 조옮김은 선형 대수 개념이며 "데이터"배열을 재정렬하려면 reshape 및 permutedims 를 권장해야합니다.

TransposedVector 와 AbstractVector 를 구별하는 유일한 의미는 * 작동하는 방식입니다.

그래서 v'==v 하지만 v'*v != v*v' ? 이것은 의미가있을 수 있지만 잠재적으로 혼란스러워 보입니다.

그래서 v'==v 하지만 v'*v != v*v' ? 이것은 의미가있을 수 있지만 잠재적으로 혼란스러워 보입니다.

IMO 이것은 피할 수 없습니다 (아마도 불행 할 수도 있습니다).

벡터의 쌍대도 벡터입니다. 전치도 여전히 잘 정의 된 요소가있는 1 차원 데이터 구조로, 가져오고, 변형하고, 매핑하고, 줄일 수 있어야합니다.

배열에서 선형 대수를 분리하지 않는 한 (예 : Matrix{T} 의 하위 유형과 Array{T,2} 의 불변 래퍼를 모두 정의하고 더 많은 (선형 대수 특정) 메서드가 정의되어 있음) 확실하지 않습니다. 배열 및 선형 대수 속성과 일치하는 많은 선택입니다.

(나에게) 한 가지 혼란스러운 질문은 그것이 벡터처럼 방송되는지 아니면 2 차원에 걸쳐 방송되는지입니다. 크기가 (1, n) 이면 첫 번째 차원이 길이 1 것으로 알려진 행렬과 같은 것을 주장하는 것을 제외하고는 전체 변경 사항이 실제로 많이 수행되지 않습니다. Vector{T} 의 조옮김은 Array{T,2} (예 : Matrix ...)로 유지되어야하지만, 그 조옮김은 다시 Vector 가 될 수 있습니다 ( 예 : v'' === v ).

그게 더 좋은 생각인가요? 그것은 덜 깨지면서 선형 대수학에서 의미론을 향상시킬 것입니다. 편집 : @martinholters 가 표시함에 따라 wrt == 다르게 작동합니다).

나에게 TransposedVector{T <: AbstractVector{Tv}} <: AbstractMatrix{Tv} *)를 사용하는 것이 size(::TransposedVector, 1)==1 이지만 transpose(::TransposedVector{T})::T 를 사용하는 것은 현명한 접근 방식처럼 들리지만, 이에 대한 좋은 주장이있을 정도로 많은 논쟁이있었습니다.

*) 이것이 구문 상 유효하지 않다는 것을 알고 있지만 의도 한 의미가 명확하기를 바랍니다.

예, 코드에서 아이디어를 가지고 놀 때 @martinholters에 동의합니다.

https://github.com/andyferris/TransposedVectors.jl 에서 시작했습니다

한 가지 큰 질문은 복잡한 활용에 대해 CTransposedVector 유형없이 살 수 있는지 아니면 처리 될 것인지입니다.

별도의 CTransposedVector 사용하지 않을 것입니다. 왜냐하면 두 가지 개념 (결합 및 재구성)을 하나의 개체로 결합하기 때문입니다. 이 두 개념을 별도의 엔티티로 구현하는 것이 훨씬 더 구성 가능합니다. 예를 들어 MappedArrays.jl을 사용하면 다음과 같이 쉽습니다.

conjview(A) = mappedarray((conj,conj), A)

그리고 당신도 훌륭한 성능을 얻습니다.

맞아, 고마워 Tim. 나는 그와 같은 것을 생각 / 희망하고 있었다. 내 유일한 관심사는 두 래퍼가 항상 "올바른"순서로 나타나는지 확인하는 방법 이었지만 지금까지 구현 한 것이 그것을 처리 할 수 ​​있다고 생각한다. 또한 우리는 이러한 모든 조합에 대해 BLAS를 지원해야합니다.

한 가지 아름다운 점은 기본적으로 conj 에서 conjview 되는 별도의 변경이이 변경에 독립적이라는 것입니다 (둘 다 독립적 인 패키지로 땜질 할 수 있고 올바르게 함께 구성 할 수 있다고 생각합니다). conj 조회수를 올리려는 욕구가 있습니까? 우리는 그러한 뷰를 무료로 만들기 위해 인라인 non-isbits 불변을 기다리고 있습니까? 아니면 기다릴 필요가 없습니까?

@andyferris : 당신의 접근 방식이 좋은 것이라고 생각합니다 – 앞으로 나아가 주셔서 감사합니다. 구현이 잘 작동하면 Base에서 해당 코드를 사용할 수 있습니다. 명심해야 할 한 가지는 https://github.com/JuliaLang/julia/issues/5332에 대해서도 TransposedMatrix를 원할 수 있다는 것

이제 변환을 계속 했으므로 전치 벡터 유형을 피해야한다고 다시 언급하겠습니다. 위에서 몇 번 언급되었지만 누구나이 문제에 대한 모든 의견을 다시 읽을 수 있을지 의심됩니다. 벡터에 대한 전치 유형을 도입하면 거의 이점이없이 상황이 복잡해집니다. 벡터가 방향을 가지고 있다고 정말로 생각한다면 그것을 행렬로 만드십시오. 행렬과 다른 선형 대수 벡터를 사용하고 벡터가 1xn 행렬처럼 동작하도록 새 래퍼 유형을 도입하는 것은 의미가 없습니다.

지금 비대칭은 x' 가 x 를 행렬로 승격하는 반면 A*x 는 x 를 행렬로 승격하지 않는다는 것입니다. 선형 대수 연산이 2D 전용이라면 A*x 는 승격되어야하고 x'x 는 1x1 행렬이됩니다. 또는 벡터를 벡터로 만들 수 있으므로 A*x 도 벡터가되지만 x' 는 noop 또는 오류 여야합니다. 전치 벡터를 도입하려면 많은 새로운 메서드 정의가 필요하며 유일한 이점은 x'x 가 스칼라가된다는 것입니다.

행렬 전치가 매우 다르다고 생각합니다. 모든 Ax_mul_Bx 메서드를 제거 할 수 있으며 벡터 전치 동작과 같은 방식으로 동작에 대해 토론 할 수 없습니다.

TransposedVector 유형을 도입하면 TransposedMatrix 유형을 도입하는 것보다 더 많은 문제가 발생하는지 실제로 알 수 없습니다.

예,이 작업의 중간 어딘가에있는 강한 합의는 벡터 전치가 이상하다는 것이었고, 구현되면 분명히 AbstractArray 의 하위 유형이되어서는 안된다는 것입니다 — 저는 size 도 허용하지 않을 것입니다 위의 요약 은 코 벡터를 포함 할 때 발생하는 몇 가지 근본적인 문제를 열거합니다. 특히 표기법입니다 (유형으로 포함하는 대신 배열에 conj 매핑하는 Tim의 접근 방식을 사용하는 것이 좋습니다. 매개 변수).

그러나 벡터 전치가 단순히 오류라는 더 강력한 요청이있었습니다. 그렇다면 실제로 패키지에 살 수 있다고 생각합니다.

벡터 전치가 오류가되는 것은 아기를 목욕물로 내 던지는 것처럼 보입니다. 벡터를 전치하기 위해 v' 를 쓸 수 없다는 것은 정말, 정말 짜증날 것입니다. 벡터 및 행렬과 곱하는 방법을 제외하고 행 행렬처럼 작동하는 TransposedVector 유형을 갖는 것에 대해 그렇게 나쁜 것은 실제로 이해하지 못합니다.

벡터 전치로 처리하려는 동작의 수에 따라 다릅니다. 당신은 단순히 원하는 경우 v'' == v , 그것은을위한 괜찮아요 typeof(v') <: AbstractMatrix . 그러나 typeof(v'v) <: Scalar 또는 typeof(v'A) <: AbstractVector 와 같이이 스레드에서 언급 한 다른 것들을 원한다면, 좀 더 복잡하고 더 복잡해야합니다.

TransposedVector를 Vector의 일종으로한다는 생각은 많은 문제의 근원 인 것 같습니다. 우리가 지금하는 것처럼 그것이 일종의 행렬이고 size(v.') == (1,length(v)) 를 갖는 것이 훨씬 덜 방해가 될 것 같습니다. 유일한 차이점은 이중 전치가 벡터를 다시 제공하고 v'v 가 스칼라를 생성한다는 것입니다. 전치를 벡터로 취급하고 싶다면 length(v') 가 정답을 제공하고 선형 인덱싱이 예상대로 작동하기 때문에 할 수 있습니다.

@StefanKarpinski와 110 % 동의합니다. 나는 그것을 벡터의 유형으로 만드는 데 놀랐지 만,이 스레드의 앞부분에서 논의 된 종류의 이유로 인해 너무 의미가 없으며 오히려 깨졌습니다.

(1, n) 크기로 만드는 접근 방식은 Array 동작 측면에서 지금과 똑같이 동작 함을 의미합니다. 1xN Matrix 과 구별되는 _only_ 연산은 ' , .' , * , \ . 및 / .

이들 중 어느 것도 "유사 배열"연산자가 아닙니다. 그들은 순전히 행렬과 벡터 사이의 선형 대수를 구현하기 위해 존재하며 MATLAB ( "행렬 실험실")에서 직접 가져옵니다. 이 최종 개선은 단순히 size(tvec, 1) = 1 컴파일러에 정적으로 v'' 를 v 하고 싶은 컴파일러 _and_라고 말합니다. (한 차원이 고정되고 다른 차원이 동적으로 크기가 조정되는 StaticArray 와 비슷하다고 생각합니다.)

단순히 v ''== v를 원하면 typeof (v ') <: AbstractMatrix에 대해 괜찮습니다.

권리.

그러나 typeof (v'v) <: Scalar 또는 typeof (v'A) <: AbstractVector와 같이이 스레드에서 언급 한 다른 사항을 원한다면 좀 더 복잡하고 다른 짐승이어야합니다.

왜? 우리는 배열과 유사한 속성을 깨뜨리지 않으므로 여전히 배열 일 수 있습니다. 모든 점 호출은 이전과 동일하게 작동하며 다른 벡터화 된 작업이 제거됩니다. * 는 Vector 및 Matrix 의 다양한 형태에 대한 지식에 "특화"되어 있으며 이는 서면 선형 대수의 동작을 모방하려고하기 때문이라고 생각합니다. v' * v 스칼라로 만드는 것은 _ 매우 _ 표준 수학이며 처음부터 그렇게되지 않은 유일한 이유는 일관된 방식으로 구현하는 것이 사소하지 않기 때문입니다 (줄리아가 얻은 영감은 MATLAB),하지만 Stefan은 이에 대해 명확히 할 수 있습니다. 내부 곱을 스칼라로 만드는 것은 여기서 말할 수있는 유일한 주요 변경 사항입니다 (다른 매우 사소한 것들이 있습니다)-그 자체만으로 Array 가되는 것이 부적합한 이유를 알 수 없습니다 (많은 유형이 있습니다). Array 중 ' , .' , * , \ 및 / 정의 됨 _ 모두 _ , 주목할만한 순위 3+)

작년에 제가 만난 문제 중 하나는 모호성이었습니다. IIRC 벡터 전치가 배열이 아닐 때 해결하기가 훨씬 더 간단했습니다.

네, 끝나기 전에 얼마나 깊어 질지 조금 걱정 되네요 ... :)

일반적으로 우리가 Base 덜 모 놀리 식으로 만들고 표준 라이브러리에 포함한다면 멋질 것입니다. AbstractArray 및 Array 만 정의하는 자체 포함 된 패키지 또는 모듈이 있으면 이러한 종류의 개발이 더 간단 해집니다.

@Jutho 의 제안에 정확히 무엇이 문제 * 가 왼쪽의 벡터를 자동으로 (결합) 전치 할 수 없습니까?

* 행렬 곱셈, ' 행렬 (켤레) 전치 (벡터는 변경되지 않음), 후행 싱글 톤 및 demote 를 추가하는 두 개의 연산자 promote 가있는 경우 후행 싱글 톤을 제거하는 demote , 오른쪽 애플리케이션 *: (n,m) -> (m,) -> (n,) , 왼쪽 애플리케이션 *: (n,) -> (n,m) -> (m,) , 스칼라 제품 *: (n,) -> (m,) -> (,) 및 외부 제품 ×: (n,) -> (m,) -> (n,m) :

(*)(A::AbstractMatrix, v::AbstractVector) = demote(A*promote(v))
(*)(u::AbstractVector, A::AbstractMatrix) = demote((promote(u)'*A)')
(*)(u::AbstractVector, v::AbstractVector) = demote(demote(promote(u)'*promote(v)))
(×)(u::AbstractVector, v::AbstractVector) = promote(u)*promote(v)'

이 연산자로 벡터를 전치해야 할 필요가 있는지 잘 모르겠습니다. 내가 뭔가를 놓치고 있습니까?

편집 : 정확히 @Jutho 의 제안은 아닙니다.

@Armavica ,이 의미를 * 에 할당하는 것이 정확히 내 제안 이었는지 확실하지 않지만 현재 dot 와 동일한 새로운 (유니 코드) 연산자 ∙ 에 할당합니다. dot . 또한 promote 및 demote 접근 방식을 유형 안정 방식으로 구현할 수 없다고 생각합니다.

저의 순수 주의자는 벡터 자체의 전치를 피해야 한다는 v'w 또는 v'*w 보다 v'w dot(v,w) 쓰기를 선호합니다). @andyferris가 제안한 방식으로 작동하도록하는 유연성. 따라서이 토론에 더 이상 추가하지 않고 실제 구현을 실행하려는 정상적인 시도를 지원하지 않을 것입니다.

맞아, @Jutho. 흥미롭게도이 둘은 상호 배타적이지 않습니다. 기본적으로 정의 된 벡터에 전치가 없다는 것은이 기능이 합법적으로 별도의 패키지, 모듈 또는 "표준 라이브러리"(즉, "타입 불법 복제"없이)에있을 수 있음을 의미합니다.

(저는 개인적으로 v'w 또는 v '* w보다 dot (v, w)를 선호합니다.)

Jutho-반면에, 나는 당신이 종이나 화이트 보드에 | ψ> ⋅ | ψ>를 쓰지 않고 오히려 <ψ | ψ>를 쓰지 않을 것이라고 확신 합니다 텐서 네트워크 다이어그램으로).

물론 저는 Dirac의 제동 표기법을 모든 수학 또는 과학에서 선형 대수의 표준 공식화로보고 싶습니다. 그리고 줄리아에서 확장하면 아마 일어나지 않을 것입니다.

이제 당신은 더 이상하지 않을 것입니다. 나는 내적에 대해 <ψ | ψ>를 선호하는 것에 확실히 동의하지만, 그것은 내가 생각하지 않는 <ψ | | ψ>의 Hermitian conjugate로. Hermitian 활용은 연산자에 대해 정의됩니다. 벡터와 관련 이중 벡터 (코 벡터, 선형 함수 등) 간의 자연 동형은 Riesz 표현 정리 로 알려져 있지만 전자는 길이 n 벡터를 선형 맵으로 해석 할 때 당연히 Hermitian conjugating과 동일합니다. C에서 C ^ n, 즉 (n,1) 크기의 행렬로.

물론 저는 Dirac의 제동 표기법을 모든 수학 또는 과학에서 선형 대수의 표준 공식화로보고 싶습니다. 그리고 줄리아에서 확장하면 아마 일어나지 않을 것입니다.

Lol

이제 당신은 더 이상하지 않을 것입니다.

미안 해요 ... 말하지 말았어야했는데 ... :)

나는 <ψ | | ψ>의 Hermitian conjugate로. Hermitian 활용은 연산자에 대해 정의됩니다.

사실, 나는 그것을 고려하지 않았습니다.

벡터와 관련 이중 벡터 (코 벡터, 선형 함수 등) 간의 자연 동형은 Riesz 표현 정리로 알려져 있지만 전자는 길이 n 벡터를 C에서 C까지의 선형 맵으로 해석 할 때 Hermitian conjugating과 동일합니다. n, 즉 크기 (n, 1)의 행렬로.

나는 탈선하지 않으려 고 노력하고 있지만 (하지만 나는 그것에 대해 나쁘다) AbstractVector 과 1D Array 연결하기 때문에이 마지막 비트를 약간 얻는 것 같습니다. 즉, AbstractVector 는 수학적 의미에서 "추상 벡터"를 의미하는 것이 아니라 "미리 정의 된 기저에 대한 벡터의 숫자 요소"를 의미합니다. 벡터의 크기가 (n,1) 였기 때문에 MATLAB은이 문제를 쉽게 해결했습니다.

생각을위한 음식으로, 당신은 무엇 형태의 모든 텐서 소요 (antilinear) 연산자를 호출 할 |a>|b><c| 하고는 매핑 |c><a|<b| ? 나는 항상 이것을 "Hermitian conjugation"과 같이 vector dual 및 standard operator conjugation과 함께 묶어 놓았지만 아마도 그것은 너무 뻔뻔 스럽습니다.

@alanedelman 과 대화하여 # 4774에 대한 내 입장에 대해 몇 가지 사항을 결정했습니다.

• Covector 또는 RowVector 유형 소개
• 선형 대수 연산의 경우 ( * , ' , .' , / , \ , 어쩌면 norm ? 기타? )이 유형은 선형 대수에서 코 벡터 역할을합니다.
• 배열 연산 (기타 모든 것)의 경우이 유형은 2 차원 1xn 배열로 작동합니다.
• 특히, 코 벡터의 size(v') 는 (1, length(v)) 입니다.

이 접근 방식을 사용하려면 Base의 모든 일반 함수를 선형 대수로 분류해야합니다. 특히 size 는 배열 함수이며 본질적으로 벡터 ( "모양"이없고 차원의 카디널리티 만 있음) 만있는 선형 대수 영역에서는 의미가 없습니다. 2 차원 배열로 표현 될 수 있음) 및 스칼라. 등장한 한 가지 특정 예는 cumsum 이며, 이는 현재 차원 인수 1이 제공된 것처럼 2 차원 배열에서 작동합니다. 이것은 sum 과 일치하지 않으며, 1의 차원 인수를 기본값으로 설정하지 않고 전체 배열의 합계를 반환합니다. 또한 cumsum 에서 작동하는 방식에 상응하는 방식으로 코 벡터에서 작동하는 것을 방지합니다. 나는 cumsum 가 N 차원 열주 순서로 누적 합산하여 일반 배열에서 작동해야한다고 생각합니다. 보다 일반적으로 차원 인수의 기본값은 1이 아닙니다.

covector를 식별하는 인터페이스가 없다면 약간 걱정이 될 것입니다. 예를 들어 size 및 ndims와 같은 대부분의 작업은 다른 2d 또는 1d 배열과 같다고 말합니다. 예를 들어 내적을 시도해야만 차이를 볼 수 있습니다. AFAICT는 객체가 RowVector인지 확인해야하지만 특정 일반 속성을 갖기 위해 객체가 특정 유형을 갖도록 요구하는 경우는 매우 드뭅니다.

@StefanKarpinski 나는 그 모든 것에 동의합니다. 특히 그 함수는 "배열"연산 또는 "선형 대수"연산입니다.

나는 당신이 말한 것과 똑같은 크기 = (1, n) TransposedVector 에서 시작했습니다 . 가능한 각 c 및 t 에 대해 * , \ , / 테스트 및 모든 조합에 대한 좋은 커버리지를 얻는 데 시간이 걸렸습니다

그것들은 Covector 와 구별되며, 여기서 그것이 실제로 켤레 전치 (또는 일반적인 경우에는 훨씬 더 일반적인 변환)이어야하며 RowVector 또는 TransposedVector 개념적으로 더 간단합니다.

@JeffBezanson "단일"차원을 갖기 위해 indices() 할 수있는 작업이 있습니까?

그러나 특정 일반 속성을 갖기 위해 객체가 특정 유형을 갖도록 요구하는 것은 매우 드뭅니다.

맞아요,이게 특징이라면 멋지 겠네요. 저는 우리가 더 일반적으로 배열에서 선형 대수를 분리 할 수 ​​있기를 바랐지만 이것은 큰 변화입니다. Julia에서 구현 된 멋진 특성 구문 없이는 깔끔 할 수 없습니다. 여기서 문제는 세 가지 (벡터, 코 벡터 및 행렬)를 두 가지 유형 ( AbstractArray{1} 및 AbstractArray{2} )에 매핑하고 있으므로 그중 하나 (코 벡터)가 특수 하위 유형이된다는 것입니다. 다른 것.

누군가가 기본 "래퍼"구현이 아닌 다른 것을 필요로하는 장소를 생각할 수 있다면 패키지에 AbstractTransposedVector 를 넣었을 것입니다.

@JeffBezanson : 나는 당신의 걱정을 얻지 못합니다. 아이디어는 선형 대수 연산을 제외하고는 1xn 2d 추상 배열처럼 작동한다는 것입니다. 코 벡터를 확인하려면 디스패치 등을 통해 유형을 확인할 수 있습니다.

이 문제를 해결하려는 시도에 대한 업데이트 :

TransposedVectors.jl 은 이제 "기능 완료"라고 생각합니다. 여기에는 @StefanKarpinski 가 여기에서 말한 것을 수행하는 데 필요한 모든 기계가 포함되어 있습니다. 벡터의 전치는 2 차원, 1xn 크기의 추상 배열로 동작하는 벡터의 래퍼입니다. 그러나 선형 대수 연산 ( * , / , \ , ' , .' 및 norm ) 행 벡터 (또는 이중 벡터)로 동작합니다.

다음과 같이 확인할 수 있습니다.

julia> Pkg.clone("https://github.com/andyferris/TransposedVectors.jl")
...

julia> using TransposedVectors
WARNING: Method definition transpose(AbstractArray{T<:Any, 1}) in module Base at arraymath.jl:416 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/TransposedVector.jl:28.
WARNING: Method definition ctranspose(AbstractArray{#T<:Any, 1}) in module Base at arraymath.jl:417 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/TransposedVector.jl:29.
WARNING: Method definition *(AbstractArray{T<:Any, 1}, AbstractArray{T<:Any, 2}) in module LinAlg at linalg/matmul.jl:86 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/mul.jl:9.
WARNING: Method definition At_mul_B(AbstractArray{#T<:Real, 1}, AbstractArray{#T<:Real, 1}) in module LinAlg at linalg/matmul.jl:74 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/mul.jl:37.
WARNING: Method definition Ac_mul_B(AbstractArray{T<:Any, 1}, AbstractArray{T<:Any, 1}) in module LinAlg at linalg/matmul.jl:73 overwritten in module TransposedVectors at /home/ferris/.julia/v0.5/TransposedVectors/src/mul.jl:64.

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

julia> vt = v'
1×3 TransposedVectors.TransposedVector{Int64,Array{Int64,1}}:
 1  2  3

julia> vt*v
14

julia> vt*eye(3)
1×3 TransposedVectors.TransposedVector{Float64,Array{Float64,1}}:
 1.0  2.0  3.0

성능 저하가있을 수 있습니다. 벤치마킹이 유용합니다. 어떤 경우에는 더 적은 복사본을 만들고 (전치가 게으른 경우) 다른 경우에는 더 많은 복사본을 만듭니다 (때로는 벡터의 공액 복사본 (매트릭스가 아님)이 예를 들어 Ac_mul_Bc 에서 생성됨). 그리고 래퍼 자체는 불변의 가변 필드를 인라인 할 때까지 약간의 비용이 듭니다 . 적절한 경우 StridedArray 종류인지 확인하는 문제도 있습니다.

사람들이이 접근 방식을 좋아한다면 곧 PR을 만들어 코드를 Base 로 마이그레이션하는 것을 볼 수 있습니다 (패키지에는 이미 단위 테스트가 있고 모든 모호성이 해결됨). (또한 @jiahao 는 이중 벡터의 1 차원 추상 배열 버전을 실험하고 싶다고 언급

사람들은 이러한 PR이 전치 행렬에 대한 래퍼 유형없이 v0.6에서 의미가 있다고 생각합니까? 전치 된 벡터는 의미 론적 변경이지만 전치 된 행렬은 최적화에 가깝기 때문에 개별적으로 들어갈 수 있다고 가정합니다. 물론, 일부 전치가 뷰이고 일부가 사본 인 경우 "이상하게"보일 수 있습니다.-의견? 고려해야 할 또 다른 점은 전치 행렬과 벡터 모두에 한 번, 많은 작업이 모두 제거 할 필요가 있다는 것입니다 At_mul_Bt 의 방법으로 대체 기능, * 의를 완료 전환 (단순화는 보람이있을 것입니다!)-누구든지 이번 달 말까지 모든 것을 할 수 있거나 할 의향이 있는지 의심됩니다 ...

@andyferris 님, 잘하셨습니다! 일반적인 게으른 Conjugate 래퍼로 실험 했습니까?

@andyferris 나는 타이어를 걷어 찼고, 이것을 꽤 좋아했습니다. 엄격하게 개선 된 것으로 보이며 성능 문제가 발견되면 처리 할 수 ​​있기를 바랍니다. 다른 사람들이 무슨 말을하는지 봅시다.

감사합니다, 여러분 :)

일반적인 게으른 Conjugate 래퍼로 실험 했습니까?

아직은 무리한 노력 없이는 가능할지 몰라도 솔직히 말해서 12 월 말까지이 정도까지 끝내지 못할까 봐 걱정이되었습니다. 미래를 내다 보면서, 결국에는 선형 대수를 위해 파견 할 다음과 같은 "unionall"유형을 가질 수 있다고 생각했습니다.

• AbstractVector
• Conjugate{V where V <: AbstractVector} (또는 Conj{V} , 어쩌면 ConjArray ? 물론 모든 차원의 배열을 허용합니다)
• TransposedVector (또는 RowVector ?)
• TransposedVector{Conjugate{V where V <: AbstractVector}}
• AbstractMatrix
• Conjugate{M where M <: AbstractMatrix}
• TransposedMatrix (또는 간단히 Transpose{M} ?)
• TransposedMatrix{Conjugate{M where M<:AbstractMatrix}}

(그리고 우리가 지금 DenseArray 및 StridedArray 라고 부르는 것과 같은 기본 스토리지의 모든 주어진 특성-# 18457이 이것들을 약간 더 쉽게 표현할 수 있기를 바랍니다).

이름을 지정하는 것 외에도 합리적인 계획처럼 들리나요?

즉각적인 자전거 흘리기와 관련하여 현재 패키지에있는 Base에 대한 PR의 경우 벡터와 행렬 모두에 대해 TransposedVector , RowVector , 일반 Transpose 래퍼를 선호합니까? , 또는 다른 것?

@andyferris 의 구현이 제공하는 동작이 꽤 좋고 개선되었다고 생각합니다. 하지만 제 걱정을 좀 더 잘 표현해 보겠습니다.

문제는 새로운 배열 유형을 정의하는 것입니다. 예를 들어 DArray 는 AbstractArray 의 하위 유형이므로 DArray 는 AbstractVector 또는 AbstractMatrix 도 될 수 있습니다. 이상적으로는 Vector / Matrix 구분을 Row / Column / Matrix로 확장하여 DArray 는 AbstractRow , AbstractCol 또는 AbstractMatrix . 유형 계층 구조는 다음과 같습니다.

    AbstractVector
        AbstractRowVector
        AbstractColumnVector
    AbstractMatrix
    ...

어제 @jiahao 와 이야기했습니다.

모든 AbstractVector 를 열로 사용할 수 없다는 점에서 우선 순위가있을 수 있습니다. 예 :

julia> isa(1.0:10.0, AbstractVector)
true

julia> randn(10,10) * 1.0:10.0
ERROR: MethodError: no method matching colon(::Array{Float64,2}, ::Float64)

https://github.com/JuliaLang/julia/issues/4774#issuecomment -59428215에서 내가 가진 문제를 해결할 수 있습니다.

범위 주변에 괄호가 누락되어 있습니까?

이는 우선 순위 문제 일뿐입니다.

julia> randn(10,10) * (1.0:10.0)
10-element Array{Float64,1}:
 -22.4311
  ⋮

여기에서 최적의 솔루션이 특성을 필요로하는 것 같다는 데 동의하지만 @andyferris 의 작업을 유지해야한다고 생각하지 않습니다.

아, 좋은 지적입니다. Fortress와 유사한 구문 오류가 잘못된 공백 우선 순위를 갖기를 원합니다.

MIT 그룹은 위에서 설명한 유형 계층 구조를 구현하는 한 가지 방법이 배열 계층 구조에 유형 매개 변수를 추가하는 것이라고 지적했습니다.

abstract AbstractArray{T,N,row}

type Array{T,N,row} <: AbstractArray{T,N,row}
end

typealias AbstractVector{T} AbstractArray{T,1}
typealias AbstractRowVector{T} AbstractArray{T,1,true}
typealias AbstractColVector{T} AbstractArray{T,1,false}
typealias AbstractMatrix{T} AbstractMatrix{T,2}

typealias Vector{T} Array{T,1,false}
typealias Matrix{T} Array{T,2,false}

나는 이것의 모든 의미를 알아 내지 못했다 --- 아마도 최악의 경우 Array{Int,1} 가 추상 유형이되는 것입니다 ---하지만 이것은 유형 계층 구조를 얻고 거의 정확하게 추상화가 필요한 것 같습니다.

그만한 가치가 있기 때문에 이것은 불완전하게 매개 변수화 된 상위 유형에 대한 사용 사례입니다. 암시 적 기본 매개 변수가 될 수 있습니다.

abstract AbstractArray{T,N,row}

type Array{T,N} <: AbstractArray{T,N}
end

isrow{T,N,row}(::AbstractArray{T,N,row}) = row
isrow{T,N}(::AbstractArray{T,N}) = false

julia> isrow(Array{Int,2}())
false

물론 파견이 조금 지저분 해지고 지원할 가치가 없을 수도 있습니다. 그냥 스핏볼 일뿐입니다.

나에게 그것은 정의와 동등 해 보이는

type Array{T,N} <: AbstractArray{T,N,false}
end

여기서 우리가 원하는 것은 일종의 "기본 유형 매개 변수"입니다. X와 Y에 자유 변수가없는 Array{X,Y} 유형을 만들면 실제로 Array{X,Y,false} 됩니다.

또 다른 아이디어 : v'*v 및 v'*A 로 구문 분석하는 대신 중위 ' 를 자체 연산자로 만들어 내적 v'v 가정부 표기법을 보존하고 왼쪽 코 벡터에 v'A 를 곱합니다. v'*A . v' ID를 만들고 v*v 오류를 만들고 v*A 오류를 만들면 원하는 것을 많이 얻을 수 있습니다. 외부 제품을 outer(v,v) 합니다.

이러한 체계에서 v' 는 noop 또는 오류 일 수 있습니다. 이러한 체계에서 벡터를 전치 할 이유가 없기 때문에 행렬에 대해서만 의미가 있습니다.

@JeffBezanson 나는 AbstractRowVector 를 갖는 것이 가장 좋을 것이라는 데 동의합니다 (하지만 솔직히 유스 케이스를 생각할 수 없기 때문에 패키지에 구현하지 않았습니다). 나는 또한 이것이 AbstractMatrix 의 하위 유형으로 살 수 있음을 지적하고 싶습니다. 제가이 방향으로 이동 한 이유는 broadcast 가 선형 대수보다 Julia에게 더 핵심 개념 인 것처럼 보이며 사람들은 행 벡터가 행이 될 것이라고 기대할 것입니다!

물론 RowVector <: AbstractMatrix 를 갖는 것은 불행한 용어 사용입니다! 나는 이것이 2D 배열과 추상 행렬에 같은 이름을 부여한 결과라고 생각합니다.

나는 이전에 이것을 훨씬 앞서 말했지만,이 문제는 너무 길기 때문에 다시 말할 것입니다. Julia와 같은 일반적인 언어에서는 "데이터 배열"속성이 AbstractArray 의 주요 고려 사항이어야합니다 broadcast 동작 방식에 답하면 1D인지 2D인지 알 수 있습니다. 행과 열로 생각하고 싶다면 1 x n 행 벡터가 가장 적합합니다. 이중 벡터를 고려하고 싶다면 1D가 가장 합리적이며 저도 만족합니다! 그러나 벡터의 이중을 취하는 것은 데이터를 재구성하는 것보다 더 복잡합니다 (예 : 적어도 접합을 지원해야 함).

나는 "행"그림이 "전형적인"프로그래머의 기대와 일치 할 것이라고 생각하지만, 고급 수학적 훈련을받은 사람들은 더 나은 추상화이기 때문에 이중 벡터를 더 잘 사용할 수있을 것입니다. 기본적인 선형 대수 지식 만있는 사람들과 공감하십시오). 그렇다면 Julia는 일반적인 MATLAB 사용자보다 수학적 기교가 더 많은 사람을 대상으로합니까?

(제 생각은 Julia가 "일반적인"프로그래밍 언어를 목표로했기 때문에 후자의 청중이 대상이었습니다).

가능한 유형 트리에 대해 논의하고 있기 때문에-미래에는 Buffer 및 크기 조정 가능한 "목록"을 사용하여

AbstractArray{T,N} # interface includes broadcast, Cartesian, getindex, setindex!, etc.
    AbstractArray{T,1}
        AbstractList{T} # resizeable, overloaded with `push!` and so-on
        AbstractVector{T} # non-resizeable, overloaded for *, /, \, ', .', etc
    AbstractArray{T,2}
        AbstractRowVector{T} # non-resizeable, overloaded for *, /, \, ', .', etc
        AbstractMatrix{T} # non-resizeable, overloaded for *, /, \, ', .', etc

물론 AbstractDualVector{T} <: AbstractArray{T,1} 대신 AbstractRowVector 있습니다.

이들 모두에 맞도록 유연하고 구체적인 Array 유형을 갖는 것은 어려울 수 있으며 아마도 불필요 할 것입니다. 특성을 통해 지원되는 인터페이스에서 이러한 차이점을보다 쉽게 ​​표현할 수 있습니다.

AbstractVector 가 C ++ std::vector 이고 선형 대수 벡터가 나에게 약간 건방진 것처럼 보였습니다. :) 선형 대수 감각 (예 : 기저 없음)

예, 크기 조정 동작을 분리하는 것이 좋습니다. 나는 그것을 위해 승선하고 있습니다.

이 유형 계층은 Base에 별도의 "matrix"및 "2-d array"콘크리트 유형이 있음을 의미하는 것 같습니다. 예를 들어 Array{T,2} 대한 생성자가 실제로 다른 행렬 유형을 반환하도록하여 문제를 해결하려고 할 수 있지만, 매우보기 흉해 보입니다. 그래도 나는 오해하고 있을지도 모릅니다.

이 유형 계층은 Base에 별도의 "matrix"및 "2-d array"콘크리트 유형이 있음을 의미하는 것 같습니다.

맞아요 ... 잘하려면 특성이 필요합니다. 나는 그것을 "인터페이스의 추상 트리"라고 불렀다는 것을 명심하십시오. 지금 이것을 시도하는 것은 당신이 말한 것처럼 추악한 것을 필요로 할 것입니다. 그러나 Buffer 가 완료 되 자마자 AbstractList <: AbstractVector 삽입하고 관련 메서드를 이동할 수 있습니다.

현재 지원되는 인터페이스와 유형 트리 간의 연결은 상당히 느슨합니다. (추상) 배열이 변경 가능한지 (즉, setindex! ), 크기 조정이 가능한지, strided가 Base 정의 된 유형에 대해서만 작동하는지 여부 등을 즉시 파악하기가 어렵습니다. 사용자가 다양한 입력으로 작동하고 효율적인 메서드를 제공하기가 어렵습니다 (이는 StaticArrays 경험입니다).

유형 계층 구조의 수학적 영역과 매개 변수화 된 추상화를위한 합리적인 역할에 대한 대화에 대한 생각. 얻을 수있을 때 Julia가 전문적으로 표현 된 의도에서 전문 지식이 의도 한 것을 수행하기 위해 코드가 작성되는 방식을 단순화하고 가볍게하는 것이 좋은 정책입니다.

우리가 사용하기로 선택할 수있는 한 가지 규칙은 Any 이외의 추상 유형을 사용하여 수반되는 구체적인 유형이 공유 된 안식처를 쉽게 찾는 가운데 존재 토폴로지 영역을 형성하는 일반적인 관행을 만듭니다. 그것은 아주 적은 비용으로 더 큰 다중 문맥 감각을 가져다 줄 것입니다-유형 계층 구조의 일부를 이해하면 다른 부분에 접근하는 데 도움이됩니다.

내가보기에, 그것은 일반화 된 교감의 원인이다. 해명적인 추상화는 생성하는 유사성 인 생성 적 유사성을 결합하는 이웃으로 조명합니다. 직관의 단순한 명확성을 전달하는 매개 변수화를 통해 Julia는 말도 안되는 시간을 줄이고 더 많은 성과를 거둘 수 있습니다.

좋아, TransposedVectors 에 대한 더 많은 의견을 주시면 감사하겠습니다. 꽤 견고 해지고 PR로 전환 될 준비가되었다고 생각하지만 여기에 나열한 몇 가지 관련 문제

(예 : RowVector 가 TransposedVector 보다 더 나은 이름입니까? [1 2 3] 가 RowVector 입니까 아니면 Matrix 입니까? indices(row, 1) ?)

RowVector의 경우 +1

2016 년 12 월 20 일 오전 7:01에 "Andy Ferris" [email protected]이 작성했습니다.

좋아, TransposedVectors 에 대한 더 많은 의견을 주시면 감사하겠습니다. 나는 느낀다
꽤 견고 해지고 PR로 바뀔 준비가되었지만
여기에 나열한 몇 가지 관련 문제
https://github.com/andyferris/TransposedVectors.jl/issues

(예 : RowVector가 TransposedVector보다 나은 이름입니까? Is [1 2
3] RowVector 또는 Matrix? 인덱스 (행, 1) 란?)

—
댓글을 달았 기 때문에 수신 한 것입니다.
이 이메일에 직접 답장하고 GitHub에서 확인하세요.
https://github.com/JuliaLang/julia/issues/4774#issuecomment-268170323 ,
또는 스레드 음소거
https://github.com/notifications/unsubscribe-auth/AAm20YYqsXmprI23GgI5PYyWStpTOq5qks5rJ309gaJpZM4BMOXs
.

행 / 열 규칙을 그대로 유지하고 싶습니다. Vector 및 RowVector (또는 ColVector 및 RowVector ). TransposedVector 또는 DualVector +1

@felixrehren 저는 DualVector 이 제가 구현 한 것과 다른 의미를 가져야한다고 생각합니다. 주로 1 차원 (수학적으로 벡터의 이중은 벡터)이고 다른 이중성 속성 (예 : 복잡한 활용)을 가져야합니다. . 괜찮지 만 구현하기가 조금 더 어렵고 이전 버전과의 호환성이 약간 떨어졌습니다.

TransposedVector 이름은 괜찮습니다. 하지만 조금 깁니다. 또한 해당 유형의 객체는 Vector 를 전치해야만 얻을 수 있음을 암시합니다. 하지만 다른 방법으로도 TransposedVector 를 만들 수 있다고 생각합니다. 예를 들어, 행렬의 한 행을 추출하여?

RowVector 가 좋은 이름이라고 생각합니다. 간결하고 정확하며 직관적입니다. @felixrehren , 행 / 열 그림이 도움이된다고 생각합니다. 연결이나 다른 일반적인 배열 연산 (곱하기 제외)을 할 때마다 벡터의 방향을 생각해야하기 때문에 피할 수 없을 수도 있습니다.

DualVector 도 나쁘지는 않지만 CoVector 은 덜 형식적으로 들릴 것입니다.

앞서 협박 한 PR은 이제 # 19670에 제출되었습니다. 지금은 RowVector 로갔습니다.

하지만 다른 방법으로도 TransposedVector를 만들 수 있다고 생각합니다. 즉, 행렬의 한 행을 추출하여?

이것은 실제로 하나의 고집 포인트입니다. 아직 이에 대한 훌륭한 구문을 생각하지 못했습니다. 어떤 아이디어?

하지만 다른 방법으로도 TransposedVector를 만들 수 있다고 생각합니다. 즉, 행렬의 한 행을 추출하여?

이것은 실제로 하나의 고집 포인트입니다. 아직 이에 대한 훌륭한 구문을 생각하지 못했습니다. 어떤 아이디어?

처음에는 matrix[scalar,range] (및 기타 유사한 구조)가 행 벡터를 생성하는 것이 매력적으로 보였지만, 이는 다차원 배열에 대한 현재 인덱싱 의미 체계에서 크게 벗어나는 것이며 특별한 경우에는 저를 걱정스럽게 만듭니다.

대신에 RowVector (그리고 그 문제에 대해서는 Vector )가 반복 가능한 유형을 적절한 종류의 벡터로 변환하는 것을보고 싶습니다. 그런 다음 RowVector(matrix[scalar,range]) 와 같은 작업을 수행 할 수 있습니다. 이는 매우 명확하고 배열 인덱싱의 현재 동작을 방해하지 않습니다.

맞습니다, i 번째 행은 A[i,:].' 의해 행 모양으로 추출 될 수 있습니다. 현재 v0.5에서는 계속해서 그렇게 할 것입니다 ( RowVector 를 만들기 위해 Transpose{V<:AbstractVector} 또는 우리가 결국 결정하는 모든 것 (진행중인 토론은 여기 참조)). 아마도 그게 답일 것입니다.

Base에 두 가지 새로운 기능을 추가하는 것은 어떻습니까?
row(A,i) 및 col(A,i)
후자는 필요하지 않지만 대칭을 위해서만 필요합니다. 간결하고 명확하며 A[i,:].' 만큼 많은 문자가 있습니다.

@benninkrs 의미가 있습니다. 반대로 내 직관적 인 해석은 벡터가 전혀 방향이없는 선형 대수 해석입니다. 이것에 대한 모든 관점은 합리적입니다. 저는 Vector 와 RowVector 함께 좋아하지 않습니다. 네이밍이 추상과 구체적인 패러다임을 혼합 한 것처럼 보이기 때문입니다.

이 시점에서 저는 @andyferris 의 구현을 기반으로하는 것을 사용하거나 벡터 전치를 심각하게 받아들이지 않기로 결정해야한다고 생각합니다. 대안의 예로, 다음은 최악의 증상을 처리하는 접근 방식입니다. v' 을 현재 상태 그대로 두십시오 (예 : 행 행렬 생성). a'b 를 바로 아래에 우선 순위가있는 중위 연산자로 구문 분석 곱셈. 즉, 다음과 같은 동작이 발생합니다.

1. v' 는 행 행렬 (ctranspose)입니다.
2. v'v 는 스칼라 (내적)입니다.
3. v'*v 는 요소를 1 개 가진 벡터 (행 행렬 * 벡터)입니다.
4. v*v' 는 외적 행렬 (벡터 * 행 행렬)입니다.
5. v'A 는 행 행렬 ( "vecmat")입니다.
6. v'*A 는 행 행렬 (matmat)입니다.
7. v'A*v 는 스칼라입니다 (matvec A * v 다음에 내적)
8. (v'A)*v 는 요소를 1 개 가진 벡터입니다 (vecmat 다음에 matvec).
9. v'*A*v 는 요소를 1 개 가진 벡터입니다 (matmat 다음에 matvec).
10. v'' 는 열 행렬 (벡터 ctranspose, 다음 행렬 ctranspose)입니다.

현재 설정에서 2와 3은 동일하고 7, 8 및 9는 동일하므로이 변경 사항이 중단됩니다. 그러나 결정적으로, 굵은 항목은 유사한 형태 중 가장 짧고 가장 편리하기 때문에 사람들이 일반적으로 도달 할 수있는 항목이며 모두 우리가 원하는대로 수행합니다. 새로운 유형이 없으며 하나의 새로운 중위 연산자 만 있습니다. 가장 큰 단점은 10 – v'' 는 여전히 열 행렬입니다. 아마도 이것은 접미사 '' 가 벡터를 열 행렬로 바꾸는 연산자이기 때문에 이점으로 볼 수 있습니다.

한 걸음 물러서서 우리가 배운 것은 추가적인 업다운 또는 차원 레이블링 기능이 없거나 2 차원 이하를 Matlab처럼 대체 가능한 것으로 취급하지 않으면 다차원 배열이 실제로 선형 대수로 원활하게 도브테일되도록 만들 수 없다는 것입니다. 그래서 우리에게 남은 것은 편리함의 문제입니다. 사람들이 배열을 지나치게 복잡하게 만들지 않고도 벡터와 행렬에 대한 일반적인 선형 대수 연산을 편리하게 표현할 수 있도록 할 수 있을까요? 저는이 접근 방식에 대해 정직하지 않았지만 배열 유형 계층 구조를 너무 많이 망가 뜨리지 않고 구문상의 편의를 해결하는이 접근 방식과 다른 접근 방식을 진지하게 고려해야한다고 생각합니다.

또 다른 접근 방식은 중위 a'b 특별히 ( * 바로 아래) 구문 분석하고 v' 가 켤레 벡터를 반환하도록하는 것입니다. 더 일반적으로 접미사 A' 는 배열을 결합하고 그 차원을 느리게 반전 할 수있는 반면 A.' 는 배열의 차원을 느리게 반전하여 벡터의 ID 역할을합니다. 이 체계에서 속성 목록은 다음과 같습니다.

1. v' 는 벡터 (공액)입니다.
2. v'v 는 스칼라 (내적)입니다.
3. v'*v (추천 오류가 v'v 내적과 outer(v,v) 외측 제품) †
4. v*v' (추천 오류가 v'v 내적과 outer(v,v) 외측 제품) †
5. v'A 는 벡터 (vecmat)입니다.
6. v'*A 은 오류입니다 (vecmat의 경우 v'A 권장).
7. v'A*v 는 스칼라입니다 (matvec A * v 다음에 내적)
8. (v'A)*v (추천 오류가 v'v 내적과 outer(v,v) 외측 제품) †
9. v'A'v 는 스칼라입니다 ( v'(A'v) – matvec 켤레와 내부 곱)
10. v'' 는 벡터입니다 ( v'' === v 및 v.' === v )

이제 이러한 속성을 모두 작성 했으므로 이것이 바람직한 옵션이 될 수 있습니다. 모든 오류 사례는 실제로 사람들이 perfered 구문을 발견하고 사용하는 데 도움이되며, 물론 바람직한 v'' === v 속성이 있습니다. .' 는 일반 차원 반전 연산자 임). 미묘하게 만 다른 매우 유사한 구문을 갖는 것은 아마도 더 혼란 스러울 것입니다.

† 사용자 코드가 ' 및 * 오버로드되어 이러한 작업이 작동하는 경우 오류를 제공 할 위험이있는보다 정확한 오류를 위해 구문 분석시 이러한 오류를 잠재적으로 포착 할 수 있습니다. 이러한 권장 사항을 수정하려면 lazy conjugate wrapper가 필요할 수 있다고 생각하지만 어쨌든 # 5332에 대해서는 필요합니다.

한 걸음 물러서서 우리가 배운 것은 추가적인 업다운 또는 차원 레이블링 기능이 없거나 2 차원 이하를 Matlab처럼 대체 가능한 것으로 취급하지 않으면 다차원 배열이 실제로 선형 대수로 원활하게 도브테일되도록 만들 수 없다는 것입니다. 그래서 우리에게 남은 것은 편리함의 문제입니다. 사람들이 배열을 지나치게 복잡하게 만들지 않고도 벡터와 행렬에 대한 일반적인 선형 대수 연산을 편리하게 표현할 수 있도록 할 수 있을까요? 저는이 접근 방식에 대해 정직하지 않았지만 배열 유형 계층 구조를 너무 많이 망가 뜨리지 않고 구문상의 편의를 해결하는이 접근 방식과 다른 접근 방식을 진지하게 고려해야한다고 생각합니다.

: 100 :

명시 적으로 접미사 ' 및 .' 일반 배열 (선형 대수 대신) 작업을 수행하면 스토리지 및 선형 대수 유형의 융합을 두 배로 줄이는 것이 좋으며 손상이 적은 프레임 워크에 대한 문을 열어 둡니다. 그 동안에는 대부분의 일반적인 경우에서 가정부 표기법을 시뮬레이션하는 이러한 작업의 기능이 원하는 편의성을 대부분 제공해야합니다. 또한 코드와 복잡성이 줄어 듭니다. 베스트!

한가지 문제 v.' 무 조작 되되지는이다 A .+ v.' 값 추가하는 의미 변경할 것이다 v 각 열에 A 값을 추가로 A 의 행에. 이것은 일반적으로 벡터로 행과 같은 연산을 수행하는 것을 더 어렵게 만들고 코드가 자동으로 잘못된 작업을 수행하는 것을 방지하기 위해 전체 폐기주기가 확실히 필요합니다 ( A 가 정사각형 인 경우).

이 시점에서 저는 @andyferris 의 구현을 기반으로하는 것을 사용하거나 벡터 전치를 심각하게 받아들이지 않기로 결정해야한다고 생각합니다.

v0.6의 마감일이 거의 다가오고 있음을 알고 있지만 아기를 목욕물에 버리지 않도록주의하겠습니다. 이 단계에서 언급 된 RowVector + 행렬 전치 및 배열 활용에 대한 뷰를 통해 다음을 얻을 수 있습니다.

• IMO, 다소 합리적인 선형 대수 유형 (행 벡터가 이중 벡터의 특수한 경우로 보일 수 있지만 지금과 같이 이중 벡터의 존재를 부정하지는 않습니다)
• v'' === v
• v1'v2 와 같은 Stefan의 목록에있는 것 중 일부는 내적입니다.
• 거의 이전 버전과 호환되는 배열 의미-예를 들어 size(v') 의 결과는 변경되지 않았지만 v'' 는 1 차원으로 있습니다.
• Lazy conj 및 transpose 래퍼는 특정 상황에서 성능을 향상시키고 어쨌든 유용 할 수 있습니다.
• * 및 A_mul_B! 만 선호하는 모든 Ac_mul_Bc 함수 제거 (및 유사하게 \ , / ).

이 모든 것을 Array 정직하게 처리하는 것은 너무 많은 노력을 기울이지 않을 것입니다 (저에게 문제는이시기에 시간을 찾고 선형 대수 모음에있는 다른 모든 유형을 추적하는 것입니다). 그리고 마지막 요점은 안도의 한숨이 될 것입니다.

반대로 IMHO 이러한 규칙은 구문 분석이 약간 복잡해 보이며 ' 로 * ' 를 구성하는 방법이 약간 혼란 스럽거나 놀라 울 수 있습니다 (3, 4, 6 및 8은 RowVector ).

그리고 예, 잠재적 인 버그를 강조하기 위해 v.' 또는 무언가를 폐기해야합니다.이 시점에서 v.' 를 누락 된 메서드 오류로 만드는 것이 거의 낫습니다 (단순히 행을 지원하지 않을 것입니다) / 이중 벡터, 그러나 원하는 경우 패키지를 중지하지 않습니다)

19670은 v0.6에 무언가를 몰래 넣고 싶은 욕구가 있다면 준비가되어 있거나 가까이있는 것으로 보입니다.

BAM

우와.

이것이 우리의 가장 긴 이슈 스레드였습니까?

아니요, # 11004에는 더 있습니다.

죄송합니다. 당신 말이 맞아요, 제가 공개 이슈 스레드를 지정 했어야 했어요.