Инверсия матрицы без Numpy

вот более элегантное и масштабируемое решение, imo. Он будет работать для любой матрицы nxn, и вы можете найти применение для других методов. Обратите внимание, что getMatrixInverse(m) принимает массив массивов в качестве входных данных. Пожалуйста, не стесняйтесь задавать любые вопросы.

def transposeMatrix(m):
    return map(list,zip(*m))

def getMatrixMinor(m,i,j):
    return [row[:j] + row[j+1:] for row in (m[:i]+m[i+1:])]

def getMatrixDeternminant(m):
    #base case for 2x2 matrix
    if len(m) == 2:
        return m[0][0]*m[1][1]-m[0][1]*m[1][0]

    determinant = 0
    for c in range(len(m)):
        determinant += ((-1)**c)*m[0][c]*getMatrixDeternminant(getMatrixMinor(m,0,c))
    return determinant

def getMatrixInverse(m):
    determinant = getMatrixDeternminant(m)
    #special case for 2x2 matrix:
    if len(m) == 2:
        return [[m[1][1]/determinant, -1*m[0][1]/determinant],
                [-1*m[1][0]/determinant, m[0][0]/determinant]]

    #find matrix of cofactors
    cofactors = []
    for r in range(len(m)):
        cofactorRow = []
        for c in range(len(m)):
            minor = getMatrixMinor(m,r,c)
            cofactorRow.append(((-1)**(r+c)) * getMatrixDeternminant(minor))
        cofactors.append(cofactorRow)
    cofactors = transposeMatrix(cofactors)
    for r in range(len(cofactors)):
        for c in range(len(cofactors)):
            cofactors[r][c] = cofactors[r][c]/determinant
    return cofactors

для матрицы 4 x 4, вероятно, почти нормально использовать математическую формулу, которую вы можете найти, используя Googling "формула для 4 на 4 матрицы обратно". Например, здесь (я не могу ручаться за его точность):

http://www.cg.info.hiroshima-cu.ac.jp/~miyazaki/knowledge/teche23.html

вообще инвертирование общей матрицы не для слабонервных. Вы должны знать обо всех математически сложных случаях и знать, почему они не будут применяться к ваше использование и поймать их, когда вы снабжены математически патологическими входами (это, или возвращать результаты низкой точности или численного мусора в знании, что это не будет иметь значения в вашем случае использования при условии, что вы на самом деле не в конечном итоге деления на ноль или переполнения MAXFLOAT ... который вы можете поймать с обработчиком исключений и представить как "ошибка: матрица сингулярна или очень близка к ней").

вообще лучше как программист использовать код библиотеки написанный численным эксперты по математике, если вы не хотите тратить время на понимание физической и математической природы конкретной проблемы, которую вы решаете, и стать своим собственным экспертом по математике в своей собственной области специалиста.

по состоянию на 16 июля 2018 Numba имеет быструю обратную матрицу. (Вы можете видеть, как они перегружают стандартные обратные и другие операции NumPy здесь.)

вот результаты моего бенчмаркинга:

import numpy as np
from scipy import linalg as sla
from scipy import linalg as nla
import numba

def gen_ex(d0):
  x = np.random.randn(d0,d0)
  return x.T + x

@numba.jit
def inv_nla_jit(A):
  return np.linalg.inv(A)

@numba.jit
def inv_sla_jit(A):
  return sla.inv(A)

для малых матриц это особенно быстро:

ex1 = gen_ex(4)
%timeit inv_nla_jit(ex1) # NumPy + Numba
%timeit inv_sla_jit(ex1) # SciPy + Numba
%timeit nla.inv(ex1)     # NumPy
%timeit sla.inv(ex1)     # SciPy

[нет]

2.54 µs ± 467 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
67.3 µs ± 9.18 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
63.5 µs ± 7.65 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
56.6 µs ± 5.03 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

обратите внимание, что ускорение работает только для numpy inverse, а не SciPy (как ожидалось).

немного больше матрица:

ex2 = gen_ex(40)
%timeit inv_nla_jit(ex2) # NumPy + Numba
%timeit inv_sla_jit(ex2) # SciPy + Numba
%timeit nla.inv(ex2)     # NumPy
%timeit sla.inv(ex2)     # SciPy

[нет]

131 µs ± 12.9 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
278 µs ± 26.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
231 µs ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
189 µs ± 11.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

так вот ускорение, но составляющей догоняет.