CODEWITHSUNDEEP
pythonmatrixtransformation
PabloG
PabloG

Reputation: 454

Transformation to simplify matrix with python

First of all thank you for any support. This is my first question published as usually my doubts are solved reading through other user's questions. Here is my question: I have a number (n) of sets with common elements. These elements are usually added sequentially creating new sets although I do not have the sequence and this is what I am trying to find. The sequence is not always perfect and at some points I have to find the closest one with some uncertainty when the sequence is not 'perfect'.

I coded it using theory of Sets searching sequentially the set that contains all the other sets and when I do not reach the last set then I start from the smallest to the bigger.

I gave some thoughts to the topic and I found, in theory, a more robust and generic approach. The idea is to build a square matrix with the n sets as row index (i) and the n sets as column index (j). The element i,j will be equal to 1 when set j is contained in i.

Here I have an example with sets A to G:

A={a, b, c, d1, d2, e, f};
B={b, c, d1, d2, e, f};
C={c, d1, d2, e, f};
D={d1, f, g};
E={d2, f, g};
F={f, g};
G={g};

If I create the matrix assuming sequence B, E, C, F, D, A, G, I would have:

    B   E   C   F   D   A   G
B   1   1   1   1   1   0   1
E   0   1   0   1   0   0   1
C   0   1   1   1   1   0   1
F   0   0   0   1   0   0   1
D   0   0   0   1   1   0   1
A   1   1   1   1   1   1   1
G   0   0   0   0   0   0   1

I should get this matrix transformed into following matrix:

    A   B   C   D   E   F   G
A   1   1   1   1   1   1   1
B   0   1   1   1   1   1   1
C   0   0   1   1   1   1   1
D   0   0   0   1   0   1   1
E   0   0   0   0   1   1   1
F   0   0   0   0   0   1   1
G   0   0   0   0   0   0   1

Which shows one of the two possible sequence: A, B, C, D, E, F, G

Here I add a picture as I am not sure matrix are shown clearly. matrix and transformed matrix

My first question is how you recommend to handle this matrix (which kind of data type should I use with typical functions to swap rows and columns).

And my second question is if there is already a matrix transformation function for this topic.

Upvotes: 2

Views: 962

Answers (2)

PabloG
PabloG

Reputation: 454

Using the swapping ideas from I made my own functions to find all the swapping to do to get the triangular matrix. Here I write the code: `def simple_sort_matrix(matrix): orden=np.array([i for i in range(len(matrix[0]))]) change=True while change: rows_index=row_index_ones(matrix) change=False #for i in range(len(rows_index)-1): i=0 while i

def swap_row_and_column(matrix,i,j): matrix[[i, j]] = matrix[[j, i]] # row swapping matrix[:, [i, j]] = matrix[:, [j, i]] # column swapping return matrix

def row_index_ones(matrix): return(np.sum(matrix,axis=1))`

Best regards, Pablo

Upvotes: 0

vladvra
vladvra

Reputation: 11

From my (small) experience, most used types for matrices are lists and numpy.ndarrays. For columns swaps in particular, I would recommend numpy. There are many array creation routines in numpy. You either give the list with data explicitly or you create an array based on the shape you want. Example

>>> import numpy as np
>>> np.array([1, 2, 3])
array([1, 2, 3])
>>> np.array([[1, 2, 3], [1, 2, 3]])
array([[1, 2, 3],
       [1, 2, 3]])
>>> np.zeros((2, 2))
array([[0., 0.],
       [0., 0.]])

np.zeros accepts a shape as an argument (number of rows and columns for matrices). Of course, you can create arrays with how many dimensions you want.

numpy is quite complex regarding indexing its arrays. For a matrix you have:

>>> a = np.arange(6).reshape(2, 3)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> a[0] # row indexing
array([0, 1, 2])
>>> a[1, 1] # element indexing
4
>>> a[:, 2] # column indexing
array([2, 5])

Hopefully the examples are self-explanatory. Regarding the column index, : means "over all the values". So you specify a column index and the fact that you want all the values on that column.

For swapping rows and columns it's pretty short:

>>> a = np.arange(6).reshape(2, 3)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> a[[0, 1]] = a[[1, 0]] # row swapping
>>> a
array([[3, 4, 5],
       [0, 1, 2]])
>>> a[:, [0, 2]] = a[:, [2, 0]] # column swapping
>>> a
array([[5, 4, 3],
       [2, 1, 0]])

Here advance indexing is used. Each dimension (called axis by numpy) can accept a list of indices. So you can get 2 or more rows/columns at the same time from a matrix. You don't have to ask for them in a certain order. numpy gives you the values in the order you ask for them.

Swapping rows is done by asking numpy for the two rows in reversed order and saving them in their original positions. It actually respects the pythonic way of swapping values between 2 variables (although surrounded by a complex frame):

a, b = b, a

Regarding matrix transformation, it depends on what you are looking for.

Upvotes: 1

Related Questions