Each Answer to this Q is separated by one/two green lines.

I think that my issue should be really simple, yet I can not find any help

on the Internet whatsoever. I am very new to Python, so it is possible that

I am missing something very obvious.

I have an array, S, like this `[x x x] (one-dimensional)`

. I now create a

diagonal matrix, `sigma`

, with `np.diag(S)`

– so far, so good. Now, I want to

resize this new diagonal array so that I can multiply it by another array that

I have.

```
import numpy as np
...
shape = np.shape((6, 6)) #This will be some pre-determined size
sigma = np.diag(S) #diagonalise the matrix - this works
my_sigma = sigma.resize(shape) #Resize the matrix and fill with zeros - returns "None" - why?
```

However, when I print the contents of `my_sigma`

, I get `"None"`

. Can someone please

point me in the right direction, because I can not imagine that this should be

so complicated.

Thanks in advance for any help!

Casper

Graphical:

I have this:

```
[x x x]
```

I want this:

```
[x 0 0]
[0 x 0]
[0 0 x]
[0 0 0]
[0 0 0]
[0 0 0] - or some similar size, but the diagonal elements are important.
```

There is a new numpy function in version 1.7.0 `numpy.pad`

that can do this in one-line. Like the other answers, you can construct the diagonal matrix with `np.diag`

before the padding.

The tuple `((0,N),(0,0))`

used in this answer indicates the “side” of the matrix which to pad.

```
import numpy as np
A = np.array([1, 2, 3])
N = A.size
B = np.pad(np.diag(A), ((0,N),(0,0)), mode="constant")
```

`B`

is now equal to:

```
[[1 0 0]
[0 2 0]
[0 0 3]
[0 0 0]
[0 0 0]
[0 0 0]]
```

`sigma.resize()`

returns `None`

because it operates in-place. `np.resize(sigma, shape)`

, on the other hand, returns the result but **instead of padding with zeros, it pads with repeats of the array**.

Also, the `shape()`

function returns the shape *of the input*. If you just want to predefine a shape, just use a tuple.

```
import numpy as np
...
shape = (6, 6) #This will be some pre-determined size
sigma = np.diag(S) #diagonalise the matrix - this works
sigma.resize(shape) #Resize the matrix and fill with zeros
```

However, this will first flatten out your original array, and then reconstruct it into the given shape, destroying the original ordering. If you just want to “pad” with zeros, instead of using `resize()`

you can just directly index into a generated zero-matrix.

```
# This assumes that you have a 2-dimensional array
zeros = np.zeros(shape, dtype=np.int32)
zeros[:sigma.shape[0], :sigma.shape[1]] = sigma
```

I see the edit… you do have to create the zeros first and then move some numbers into it. `np.diag_indices_from`

might be useful for you

```
bigger_sigma = np.zeros(shape, dtype=sigma.dtype)
diag_ij = np.diag_indices_from(sigma)
bigger_sigma[diag_ij] = sigma[diag_ij]
```

This solution works with `resize`

function

Take a sample array

```
S= np.ones((3))
print (S)
# [ 1. 1. 1.]
d= np.diag(S)
print(d)
"""
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
"""
```

This **dosent** work, it just add a repeating values

```
np.resize(d,(6,3))
"""
adds a repeating value
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.],
[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
"""
```

This **does** work

```
d.resize((6,3),refcheck=False)
print(d)
"""
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]
[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
"""
```

Another pure python solution is

```
a = [1, 2, 3]
b = []
for i in range(6):
b.append((([0] * i) + a[i:i+1] + ([0] * (len(a) - 1 - i)))[:len(a)])
```

`b`

is now

```
[[1, 0, 0], [0, 2, 0], [0, 0, 3], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
```

it’s a hideous solution, I’ll admit that.

However, it illustrates some functions of the `list`

type that can be used.