Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

from numpy.lib import add_newdoc 

 

add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', 

""" 

LU factorization of a sparse matrix. 

 

Factorization is represented as:: 

 

Pr * A * Pc = L * U 

 

To construct these `SuperLU` objects, call the `splu` and `spilu` 

functions. 

 

Attributes 

---------- 

shape 

nnz 

perm_c 

perm_r 

L 

U 

 

Methods 

------- 

solve 

 

Notes 

----- 

 

.. versionadded:: 0.14.0 

 

Examples 

-------- 

The LU decomposition can be used to solve matrix equations. Consider: 

 

>>> import numpy as np 

>>> from scipy.sparse import csc_matrix, linalg as sla 

>>> A = csc_matrix([[1,2,0,4],[1,0,0,1],[1,0,2,1],[2,2,1,0.]]) 

 

This can be solved for a given right-hand side: 

 

>>> lu = sla.splu(A) 

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

>>> x = lu.solve(b) 

>>> A.dot(x) 

array([ 1., 2., 3., 4.]) 

 

The ``lu`` object also contains an explicit representation of the 

decomposition. The permutations are represented as mappings of 

indices: 

 

>>> lu.perm_r 

array([0, 2, 1, 3], dtype=int32) 

>>> lu.perm_c 

array([2, 0, 1, 3], dtype=int32) 

 

The L and U factors are sparse matrices in CSC format: 

 

>>> lu.L.A 

array([[ 1. , 0. , 0. , 0. ], 

[ 0. , 1. , 0. , 0. ], 

[ 0. , 0. , 1. , 0. ], 

[ 1. , 0.5, 0.5, 1. ]]) 

>>> lu.U.A 

array([[ 2., 0., 1., 4.], 

[ 0., 2., 1., 1.], 

[ 0., 0., 1., 1.], 

[ 0., 0., 0., -5.]]) 

 

The permutation matrices can be constructed: 

 

>>> Pr = csc_matrix((4, 4)) 

>>> Pr[lu.perm_r, np.arange(4)] = 1 

>>> Pc = csc_matrix((4, 4)) 

>>> Pc[np.arange(4), lu.perm_c] = 1 

 

We can reassemble the original matrix: 

 

>>> (Pr.T * (lu.L * lu.U) * Pc.T).A 

array([[ 1., 2., 0., 4.], 

[ 1., 0., 0., 1.], 

[ 1., 0., 2., 1.], 

[ 2., 2., 1., 0.]]) 

""") 

 

add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('solve', 

""" 

solve(rhs[, trans]) 

 

Solves linear system of equations with one or several right-hand sides. 

 

Parameters 

---------- 

rhs : ndarray, shape (n,) or (n, k) 

Right hand side(s) of equation 

trans : {'N', 'T', 'H'}, optional 

Type of system to solve:: 

 

'N': A * x == rhs (default) 

'T': A^T * x == rhs 

'H': A^H * x == rhs 

 

i.e., normal, transposed, and hermitian conjugate. 

 

Returns 

------- 

x : ndarray, shape ``rhs.shape`` 

Solution vector(s) 

""")) 

 

add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('L', 

""" 

Lower triangular factor with unit diagonal as a 

`scipy.sparse.csc_matrix`. 

 

.. versionadded:: 0.14.0 

""")) 

 

add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('U', 

""" 

Upper triangular factor as a `scipy.sparse.csc_matrix`. 

 

.. versionadded:: 0.14.0 

""")) 

 

add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('shape', 

""" 

Shape of the original matrix as a tuple of ints. 

""")) 

 

add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('nnz', 

""" 

Number of nonzero elements in the matrix. 

""")) 

 

add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('perm_c', 

""" 

Permutation Pc represented as an array of indices. 

 

The column permutation matrix can be reconstructed via: 

 

>>> Pc = np.zeros((n, n)) 

>>> Pc[np.arange(n), perm_c] = 1 

""")) 

 

add_newdoc('scipy.sparse.linalg.dsolve._superlu', 'SuperLU', ('perm_r', 

""" 

Permutation Pr represented as an array of indices. 

 

The row permutation matrix can be reconstructed via: 

 

>>> Pr = np.zeros((n, n)) 

>>> Pr[perm_r, np.arange(n)] = 1 

"""))