column operator erases complex property

1 次查看（过去 30 天）

Bruno Luong 2020-10-18

3
链接

此问题的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/618088-column-operator-erases-complex-property

评论： Walter Roberson 2022-3-29

Why column (:) changes my data? (R2020b)

>> z=complex(3,0)
z =
  3.000000000000000 + 0.000000000000000i
>> isreal(z)
ans =
  logical
   0
>> isreal(reshape(z,[],1))
ans =
  logical
   0
>> isreal(z(:)) %%%% <= only column returns 1
ans =
  logical
   1

21 个评论
显示 19更早的评论隐藏 19更早的评论

Walter Roberson 2020-10-19

编辑：Walter Roberson 2020-10-19

Visashta:

The Tips section of complex() is telling you that complex() is a special function that can explicitly construct variables that have complex part that is all zero, but that the form A+B*i is considered an expression adding A and i*B and that since that is an expression, any all-zero imaginary part will be dropped.

Yes, complex part all-zero is a special case in MATLAB, and the boundaries of that special case are exactly what we are exploring here. It has always been the case that an all-zero complex part will not be lost when you copy or pass a variable, but that it would normally be lost if you use the variable in an expression. The question then arises whether calling reshape() or indexing with (:) should be considered an expression for the purposes of losing the all-zero part. Bruno demonstrated that reshape() does not lose the all-zero complex component, which fits in with the known implementation of reshape() as being about changing the dimension header while using exactly the same data pointer(s) .

Indexing with (:) has long been discussed as being a short-cut for reshape() into a column vector, and if that is the case then because reshape() does not lose the all-zero complex part, it would be unexpected that (:) would lose the all-zero complex part.

We can then ask the question of whether (:) is instead considered an expression rather than just a shortcut to reshape() into a single column. But if it were an expression, then we would expect that for real-valued z, z(:) would copy the data instead of sharing it, leading to a different data pointer. A minor bit of testing shows that is not the case, that when z only contains real values that z(:) shares data.

So... z(:) with complex z is somehow being treated specially, and losing all-zero complex part. z(:) with complex z is giving back a different data pointer.

Next we test

>> format debug
>> z = complex([1 2 3],4)
z =
Structure address = 1dc3db9a0
m = 1
n = 3
pr = 6040044bac60
   1.0000 + 4.0000i   2.0000 + 4.0000i   3.0000 + 4.0000i
>> reshape(z,[],1)
ans =
Structure address = 1dc3d95a0
m = 3
n = 1
pr = 6040044bac60
   1.0000 + 4.0000i
   2.0000 + 4.0000i
   3.0000 + 4.0000i
>> z(:)
ans =
Structure address = 1dc3d8d00
m = 3
n = 1
pr = 608005e83260
   1.0000 + 4.0000i
   2.0000 + 4.0000i
   3.0000 + 4.0000i

Notice that when we did the reshape() that the data pointer stayed the same, but when we did the (:) that the data pointer changed. That does not happen when z has no complex part.

>> z1 = [1 2 3]
z1 =
Structure address = 1dc3da500
m = 1
n = 3
pr = 60800d076ca0
     1     2     3
>> reshape(z1,[],1)
ans =
Structure address = 1dc3d9c60
m = 3
n = 1
pr = 60800d076ca0
     1
     2
     3
>> z1(:)
ans =
Structure address = 1dc3d8d00
m = 3
n = 1
pr = 60800d076ca0
     1
     2
     3

The problem therefor expands a bit beyond what Bruno originally posted, becoming instead the question:

What is (:) treated like an expression for complex z, but treated as reshape() for non-complex z?

With it being treated as an expression, losing the all-zero part would be automatic.

Bruno Luong 2022-3-28

It seems

sortrows works on complex input then decide to "cast" the sorted result to real.
sort(z) does not post cast.
Whereas sort(z(:)) cast the input first.

Walter Roberson 2022-3-29

@Bruno Luong

The part I was forgetting was this from sort:

If A is complex, then by default, sort sorts the elements by magnitude. If more than one element has equal magnitude, then the elements are sorted by phase angle on the interval (−π, π].

But these days there is a 'ComparisonMethod' option, of 'real' or 'magnitude'

请先登录，再进行评论。

请先登录，再回答此问题。

采纳的回答

Walter Roberson 2020-10-18

1
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/618088-column-operator-erases-complex-property#answer_517403

For reasons I do not understand, z(:) is being treated as an expression. If you make z larger but complex, then reshape(z,[],1) keeps the same data pointer, but z(:) creates a new data pointer each time -- which is not the case if z is not complex.

I have two speculations at the moment:

Hypothetically, since array indexing is treated as an expression, Mathworks might have wanted consistency around dropping the complex part of expressions when the complex part was all zero. This explanation is a bit weak as it does not explain why they did not treat reshape() the same way, and does not explain why scalar z keeps the same data pointer (but non-scalar z does not.)
Hypothetically, it might have to do with the change to representation of complex in R2018a. This explanation is a bit weak as it does not explain why they did not treat reshape() the same way, and does not explain why scalar z keeps the same data pointer (but non-scalar z does not.) On the other hand, this hypothesis has the merit that it would be testable by going back to R2017b and seeing if (:) had the same behaviour there.

7 个评论
显示 5更早的评论隐藏 5更早的评论

Bruno Luong 2021-7-28

How to ask TMW a behavior that is not documented nor a bug?

Jan 2021-7-28

@Bruno Luong: You are Bruno. Just write them an email and ask for an explanation. From time to a developper has called by by phone to explain details concerning a discussion in the forum. They are interested in active users.

请先登录，再进行评论。