[SciPy-Dev] linalg.toeplitz and ticker #667
josef.pktd@gmai...
josef.pktd@gmai...
Sun Mar 7 20:05:47 CST 2010
On Sun, Mar 7, 2010 at 8:32 PM, Warren Weckesser
<warren.weckesser@enthought.com> wrote:
> Warren Weckesser wrote:
>> I am going to update linalg.toeplitz to fix the problem reported in
>> ticket #667, but I have some questions about the desired behavior of
>> the function when either `c` (the first column) or `r` (the first row)
>> is complex. The docstring does not say anything about complex values,
>> but the code does some undocumented and unexpected things in this
>> case, one example of which is the bug reported in the ticket #667.
>>
>> I would like to fix this, but I would first like opinions on exactly
>> how it *should* handle complex arguments. I *think* the idea is that
>> if `c` is complex and `r` is not given, then a Hermitian Toeplitz
>> matrix is created. Is that correct? Note that this requires that
>> c[0] be real, since c[0] is the value that will be in the diagonal of
>> the matrix.
>>
>> While I am fixing this, I would like to remove the printed warning
>> that occurs when r[0] != c[0]. I would like to change this to raise
>> a ValueError--that is, adopt the philosophy that either the arguments
>> are correct (and the code handles them as [not yet, but soon to be]
>> documented in the docstring, with no warnings needed), or the
>> arguments are wrong and an exception should be raised.
>>
>> This means that when `r` is not given, an exception would be raised
>> if c[0] is not real.
>>
>> A very different way to handle the case of `r` not being given is to
>> assume it means a square matrix should be created with r[1:] = 0
>> (i.e. zeros in all the upper off-diagonals). This avoids the whole
>> issue of complex numbers and conjugates, but it is also a more
>> drastic change.
a lot of code relies on toeplitz of a single argument to build the
symmetric matrix.
>>
>>
>
> By the way, that is how linalg.hankel handles the case where `r` is not
> given.
??
>>> import scipy.linalg
>>> scipy.linalg.toeplitz(np.arange(4))
array([[0, 1, 2, 3],
[1, 0, 1, 2],
[2, 1, 0, 1],
[3, 2, 1, 0]])
>>> scipy.linalg.hankel(np.arange(4))
array([[ 0., 1., 2., 3.],
[ 1., 2., 3., 0.],
[ 2., 3., 0., 0.],
[ 3., 0., 0., 0.]])
>>>
>>> scipy.linalg.hankel(np.arange(4)+1.j)
array([[ 0.+1.j, 1.+1.j, 2.+1.j, 3.+1.j],
[ 1.+1.j, 2.+1.j, 3.+1.j, 0.+0.j],
[ 2.+1.j, 3.+1.j, 0.+0.j, 0.+0.j],
[ 3.+1.j, 0.+0.j, 0.+0.j, 0.+0.j]])
>>> scipy.linalg.toeplitz(np.arange(4)+1.j)
Warning: column and row values don't agree; column value used.
array([[ 0.+1.j, 1.+1.j, 2.+1.j, 3.+1.j],
[ 1.-1.j, 0.+1.j, 1.+1.j, 2.+1.j],
[ 2.-1.j, 1.-1.j, 0.+1.j, 1.+1.j],
[ 3.-1.j, 2.-1.j, 1.-1.j, 0.+1.j]])
requiring the diagonal to be real might be too tough, I'm not using
complex toeplitz, but for other cases, I often have "almost real"
values, up to numerical imprecision.
>>> scipy.linalg.toeplitz(np.arange(4)*1.j,-np.arange(4)*1.j)
array([[ 0.+0.j, 0.-1.j, 0.-2.j, 0.-3.j],
[ 0.+1.j, 0.+0.j, 0.-1.j, 0.-2.j],
[ 0.+2.j, 0.+1.j, 0.+0.j, 0.-1.j],
[ 0.+3.j, 0.+2.j, 0.+1.j, 0.+0.j]])
also for real values r[0] != c[0] might not be satisfied if there is
numerical imprecision and they are only almost equal.
Josef
>
>
> Warren
>
> _______________________________________________
> SciPy-Dev mailing list
> SciPy-Dev@scipy.org
> http://mail.scipy.org/mailman/listinfo/scipy-dev
>
More information about the SciPy-Dev
mailing list