Как найти диагональ матрицы python - Сайт, где вы сможете решить свои вопросы

numpy.diagonal(a, offset=0, axis1=0, axis2=1)[source]#

Return specified diagonals.

If a is 2-D, returns the diagonal of a with the given offset,
i.e., the collection of elements of the form a[i, i+offset]. If
a has more than two dimensions, then the axes specified by axis1
and axis2 are used to determine the 2-D sub-array whose diagonal is
returned. The shape of the resulting array can be determined by
removing axis1 and axis2 and appending an index to the right equal
to the size of the resulting diagonals.

In versions of NumPy prior to 1.7, this function always returned a new,
independent array containing a copy of the values in the diagonal.

In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,
but depending on this fact is deprecated. Writing to the resulting
array continues to work as it used to, but a FutureWarning is issued.

Starting in NumPy 1.9 it returns a read-only view on the original array.
Attempting to write to the resulting array will produce an error.

In some future release, it will return a read/write view and writing to
the returned array will alter your original array. The returned array
will have the same type as the input array.

If you don’t write to the array returned by this function, then you can
just ignore all of the above.

If you depend on the current behavior, then we suggest copying the
returned array explicitly, i.e., use np.diagonal(a).copy() instead
of just np.diagonal(a). This will work with both past and future
versions of NumPy.

Parameters:

aarray_like: Array from which the diagonals are taken.
offsetint, optional: Offset of the diagonal from the main diagonal. Can be positive or
negative. Defaults to main diagonal (0).
axis1int, optional: Axis to be used as the first axis of the 2-D sub-arrays from which
the diagonals should be taken. Defaults to first axis (0).
axis2int, optional: Axis to be used as the second axis of the 2-D sub-arrays from
which the diagonals should be taken. Defaults to second axis (1).

Returns:

array_of_diagonalsndarray

If a is 2-D, then a 1-D array containing the diagonal and of the
same type as a is returned unless a is a matrix, in which case
a 1-D array rather than a (2-D) matrix is returned in order to
maintain backward compatibility.

If a.ndim > 2, then the dimensions specified by axis1 and axis2
are removed, and a new axis inserted at the end corresponding to the
diagonal.

Raises:

ValueError: If the dimension of a is less than 2.

Синтаксис

Параметры

Функция принимает два параметра, один из которых является необязательным.

Первый параметр — это входной массив, представленный arr.
Второй параметр — k, является необязательным и по умолчанию принимает значение 0. Если значение этого параметра больше 0, это означает, что диагональ находится выше главной диагонали, и наоборот, если нет.

Возвращаемое значение

Возвращает массив с диагональным массивом.

Примеры программ для метода diag() в Python

Напишем программу, показывающую работу функции diag() в Python.

Пример 1

# app.py

import numpy as np

a = np.matrix([[1, 2, 3], [4, 5, 6], [9, 8, 7]])

print(“Main Diagonal: n”, np.diag(a), “n”)

print(“Above main diagonal: n”, np.diag(a, 1),

“n”) # k=1(for above main diagonal)

print(“Below main diagonal: n”, np.diag(a, –1)) # k=-1(for below main diagonal)

Выход

Main Diagonal: [1 5 7]

Above main diagonal: [2 6]

Below main diagonal: [4 8]

В этом примере мы используем numpy diag() и можем видеть, что, передавая разные значения k, можем получить их диагональные элементы. Здесь мы увидели главную диагональ в матрице, затем диагональ выше главной диагонали при передаче значения k=1 и наоборот при передаче значения k=-1.

Пример 2

Напишем программу, которая берет матрицу 4×4 и применяет функцию diag().

См. следующий код.

# app.py

import numpy as np

a = np.matrix([[1, 2, 3], [4, 5, 6], [9, 8, 7], [11, 13, 15]])

print(“Main Diagonal: n”, np.diag(a), “n”)

# k=1(for above main diagonal)

print(“Above main diagonal: n”, np.diag(a, 1), “n”)

#k=-1(for below main diagonal)

print(“Below main diagonal: n”, np.diag(a, –1))

Выход

python3 app.py

Main Diagonal:

[1 5 7]

Above main diagonal:

[2 6]

Below main diagonal:

[ 4 8 15]

В этом примере мы передали матрицу 4 × 4 и получили требуемый результат главной диагонали, выше главной диагонали (k = 1) и ниже главной диагонали (k = -1).

Создание массива и построение диагонали

См. следующий код.

import numpy as np

data = np.arange(12).reshape((4,3))

print(data)

dignl = np.diag(data, k=0)

print(‘The diagonal is: ‘)

print(dignl)

Выход

python3 app.py

[[ 0 1 2]

[ 3 4 5]

[ 6 7 8]

[ 9 10 11]]

The diagonal is:

[0 4 8]

В этом примере мы взяли k = 0. Это главная диагональ, которая состоит из

Если мы возьмем k = 1, он вернет [1, 5]. См. следующий код.

# app.py

import numpy as np

data = np.arange(12).reshape((4,3))

print(data)

dignl = np.diag(data, k=1)

print(‘The diagonal is: ‘)

print(dignl)

Выход

python3 app.py

[[ 0 1 2]

[ 3 4 5]

[ 6 7 8]

[ 9 10 11]]

The diagonal is:

[1 5]

Если мы возьмем k = -1, это даст нам нижнюю диагональ главной диагонали.

См. следующий код.

import numpy as np

data = np.arange(12).reshape((4, 3))

print(data)

dignl = np.diag(data, k=–1)

print(‘The diagonal is: ‘)

print(dignl)

Выход

python3 app.py

[[ 0 1 2]

[ 3 4 5]

[ 6 7 8]

[ 9 10 11]]

The diagonal is:

[ 3 7 11]

Главная диагональ нашего массива — [0, 4, 8], а нижняя диагональ — [3, 7, 11]. Вот почему, когда мы устанавливаем k=-1, он вернет [3, 7, 11]. Если вы передадите k = -2, то он вернет [6, 10]

Построение диагонали из массива NumPy

Если вы хотите создать диагональ из массива, вы можете использовать метод np diag().

# app.py

import numpy as np

a = np.array([1, 2, 3, 4])

print(a)

d = np.diag(a)

print(‘The diagonal is: ‘)

print(d)

Выход

python3 app.py

[1 2 3 4]

The diagonal is:

[[1 0 0 0]

[0 2 0 0]

[0 0 3 0]

[0 0 0 4]]

Если у вас есть вектор-строка, вы можете сделать следующее.

# app.py

import numpy as np

a = np.array([[1, 2, 3, 4]])

print(a)

d = np.diag(a[0])

print(‘The diagonal is: ‘)

print(d)

Выход

python3 app.py

[[1 2 3 4]]

The diagonal is:

[[1 0 0 0]

[0 2 0 0]

[0 0 3 0]

[0 0 0 4]]

Заключение

Функция Python numpy.diagonal() используется для извлечения диагонали и записи в полученный массив; возвращает она копию или представление, зависит от того, какую версию numpy вы используете.

Источник

Получение диагоналей в матрице. Алгоритм

Одна из причин, почему я захотел написать строчки насчет этого алгоритма, так как сам в большинстве случаев находил лишь вариант решения с numPy. Это, безусловно, отличная библиотека, но все же интересен сам алгоритм для использования в различных целях. Ну а начать, пожалуй, хочется с минимальным количеством воды, поэтому сразу начну с объяснения метода.

Очевидное, что приходит в голову, что если «продлить» диагонали, или же, другими словами, представить диагонали в виде набора элементов, то количество тех самых элементов будет равно, но не все матрицы будут заполнены «по максимуму». Посмотрим на изображение 1, в котором числами сверху отмечены номера диагоналей и они проведены через элементы таблицы чисел. Не трудно осознать, что количество таких диагоналей равно $inline$N + M – 1$inline$, где N — количество строк в таблице, а M — количество столбцов в таблице. Пускай номера диагоналей, чье начало начинается с отсутствия элементов, обозначим зеленым цветом для удобства понимания.

В голову напрашивается очевидный вариант, как можно получить все диагонали с их элементами. А точнее, перебрать $inline$N + M – 1$inline$, в начале пусто заполненных, диагоналей и заполнить их соответствующими элементами. Перебирать будем в диапазоне

$$display$$[-(N – 1); M)$$display$$

, поскольку все числа, какие будут «с минусом» в данном диапазоне будет, как раз, равно кол-ву диагоналям, чье начало идет с «пустыми элементами», а точнее вообще без ничего и будет равно кол-ву $inline$N – 1 = (N + M – 1 – M)$inline$. Удобно использовать в реализации.

diagonals = [[] for i in range(N + M - 1)]
for i in range(-(N - 1), M):
....

Изображение 1

Соображение №1

Давайте выясним, как можно заполнить нужными элементами. Для начала вспомним, что элементы главной диагонали подчиняются правилу, что индекс позиции элемента a (= a[i][i]), где i — номер столбца и строки соответственно. Теперь можно обратить внимание, что другие безымянные диагонали отличаются лишь позицией лишь началом «отсчёта». В общем виде каждый $inline$i$inline$-овый элемент дополнительных диагоналей, параллельных главной диагонали, можно выразить так: $inline$b[i] = a[i][i + j]$inline$, $inline$b$inline$ — набор элементов диагонали, где $inline$i$inline$ — номер элемента, $inline$j$inline$ — «коэффициент отклонения диагонали», то есть на сколько столбец уходит в сторону от нулевого. Влево, вправо — неважно. И также, безусловно, условия, чтобы не выходить за границы.
Получаем:

$$display$$begin{cases} b[i] = a[i][i + j], &text{где $i$ – это номер элемента в $j + N – 1$ диагонали, $a$ – исходная матрица} \ 0 <= i < n \ 0 <= i + j < m end{cases}$$display$$

То есть достаточно добавить до N элементов в набор каждой диагонали. Отметим, что если индекс выходит за границы размера таблицы, то элемент явно не является частью набор любой диагонали. Также поскольку номер позиции каждого элемента диагонали = номеру строки, в которой он находится, то значение некому row присвоим j. Столбец (col), можно понять, что равен i + j, исходя из соображения под номером (1). Нам остается лишь обязательно учитывать границы row и col, дабы избежать выхода из границ существующих элементов для наших диагоналей.

diagonals = [[] for i in range(N + M - 1)]
for i in range(-(N - 1), M):
    for j in range(N):
        row, col = j, i + j
        if 0 <= row < len(matrix) and 0 <= col < len(matrix[0]):
            diagonals[i + len(matrix) - 1].append(matrix[row][col])

Также этот алгоритм можно немного изменить, чтобы проделать процесс относительно диагоналей, параллельных побочной диагонали, изменив лишь эту строчку таким образом:

diagonals[i + len(matrix) - 1].append(matrix[row][M - col - 1])

На этом в принципе все. Нетрудный для понимания алгоритм поможет найти все диагонали в матрице.

Источник

Improve Article

Save Article

Like Article

Read

Discuss

Improve Article

Save Article

Like Article

With the help of Numpy matrix.diagonal() method, we are able to find a diagonal element from a given matrix and gives output as one dimensional matrix.

Syntax : matrix.diagonal()

Return : Return diagonal element of a matrix

Example #1 :
In this example we can see that with the help of matrix.diagonal() method we are able to find the elements in a diagonal of a matrix.

import numpy as np

gfg = np.matrix('[6, 2; 3, 4]')

geeks = gfg.diagonal()

print(geeks)

Example #2 :

import numpy as np

gfg = np.matrix('[1, 2, 3; 4, 5, 6; 7, 8, 9]')

geeks = gfg.diagonal()

print(geeks)

Last Updated :
12 Apr, 2019

Like Article

Save Article

Источник

The Numpy library in Python comes with a number of useful functions to work with and manipulate the data in arrays. In this tutorial, we will look at how to create a diagonal matrix using Numpy with the help of some examples.

create a diagonal matrix in numpy

You can use the numpy built-in numpy.diag() function to create a diagonal matrix. Pass the 1d array of the diagonal elements.

The following is the syntax –

numpy.diag(v, k)

To create a diagonal matrix you can use the following parameters –

v – The 1d array containing the diagonal elements.
k – The diagonal on which the passed elements (elements of the 1d array, v) are to be placed. By default, k is 0 which refers to the main diagonal. Diagonals above the main diagonal are positive and the ones below it are negative (see the examples below).

It returns a 2d array with the passed elements placed on the kth diagonal.

Examples

Let’s now look at examples of using the above syntax to get create a diagonal matrix using the Numppy library.

Example 1 – Diagonal matrix from 1d array placed on the default diagonal in Numpy

Let’s now use the numpy.diag() function to create a diagonal matrix from a 1d array. For example, we’ll only pass the 1d array and use the default diagonal.

import numpy as np

# create a 1d array of diagonal elements
ar = np.array([1, 2, 3])
# create a diagonal matrix
res = np.diag(ar)
# display the returned matrix
print(res)

Output:

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

We get a 2d numpy array which is a diagonal matrix. All the elements in the matrix are zero except the diagonal elements. You can see that the passed elements are placed on the main diagonal (k=0).

Example 2 – Diagonal matrix from 1d array placed on a custom diagonal in Numpy

In the above example, we placed the elements from the 1d array of the main diagonal.

The numpy.diag() function comes with an optional parameter, k that you can use to specify the diagonal you want to use to create the diagonal matrix.

The below image better illustrates the different values of k (representing different diagonals) for a 3×3 matrix.

k is 0 by default. The diagonals below the main diagonal have k < 0 and the diagonals above it have k > 0.

Let’s now use the numpy.diag() function to create a diagonal matrix by placing the passed elements on the k=-1 diagonal.

# create a 1d array of diagonal elements
ar = np.array([1, 2, 3])
# create a diagonal matrix with elements on digonal, k=-1
res = np.diag(ar, k=-1)
# display the returned matrix
print(res)

Output:

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

The resulting diagonal matrix has the passed elements on the k = -1 diagonal. Here, the resulting matrix is 4×4 because all the elements in the passed array cannot be accommodated on the k=-1 diagonal of a 3×3 matrix, hence the added dimensions.

Alternative usage of the `numpy.diag()` function

In the above examples, we used the numpy.diag() function to create a diagonal matrix by passing a 1d array and placing its elements on the kth diagonal.

You can also use the numpy.diag() function to extract the diagonal elements from a 2d array.

For example, if you pass a 2d array to the numpy.diag() function, it will return its diagonal elements on the kth diagonal (which is 0 by default).

# create a 2D numpy array
arr = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])
# get the diagonal elements
res = np.diag(arr)
# display the diagonal elements
print(res)

Output:

[1 5 9]

We get the elements on the main diagonal as a 1d array.

Summary

In this tutorial, we looked at how to create a diagonal matrix using a 1d array in Numpy. The following are the key takeaways from this tutorial.

Use the numpy.diag() function to create a diagonal matrix. Pass the diagonal elements as a 1d array.
You can specify the diagonal to place the elements in the passed array on using the optional parameter k. By default, it represents the main diagonal, k = 0.

Синтаксис

Параметры

Возвращаемое значение

Примеры программ для метода diag() в Python

Пример 1

Пример 2

Создание массива и построение диагонали

Построение диагонали из массива NumPy

Заключение

Получение диагоналей в матрице. Алгоритм

Соображение №1

Examples

Example 1 – Diagonal matrix from 1d array placed on the default diagonal in Numpy

Example 2 – Diagonal matrix from 1d array placed on a custom diagonal in Numpy

Alternative usage of the numpy.diag() function

Summary

Вам также может понравиться

Как найти сторону через угол формула

Арк как найти овиса

Mmloaddrv exe ошибка как исправить

Добавить комментарий Отменить ответ

Alternative usage of the `numpy.diag()` function