I am trying to solve a matrix of this form:
Is there a known algorithm or a method to solve this kind of matrices more efficiently than a normal Gauß elimination method?
I input the diagonals as vectors, so the main diagonal (green) in A, B is the 1st lower diagonal (lower yellow), C = B[::-1] is the 1st upper diagonal (upper yellow), D is the 2nd lower diagonal (lower blue), E = D[::-1] is the 2nd upper diagonal (upper blue), F is the 3rd lower diagonal (lower orange) and G = F[::-1] is the 3rd upper diagonal (upper orange).
The result vector is H = [0,value,value,value,value,value,value,value,0]
How get the solution vector x?
Here is my code:
def fd_8(x, v, w, t, a, b): """Implements the shooting method to solve linear second order BVPs Compute finite difference solution to the BVP but with the 8-order formula! t should be passed in as an n element array. x, v, and w should be either n element arrays corresponding to x(t), v(t) and w(t) or scalars, in which case an n element array with the given value is generated for each of them. USAGE: u'' = x(t) + v(t) u + w(t) u' u = fd(x, v, w, t, a, b) INPUT: x,v,w - arrays containing x(t), v(t), and w(t) values. May be specified as Python lists, NumPy arrays, or scalars. In each case they are converted to NumPy arrays. t - array of n time values to determine u at a - solution value at the left boundary: a = u(t) b - solution value at the right boundary: b = u(t[n-1]) OUTPUT: u - array of solution function values corresponding to the values in the supplied array t. """ # Get the dimension of t and make sure that t is an n-element vector if type(t) != np.ndarray: if type(t) == list: t = np.array(t) else: t = np.array([ float( t ) ]) n = len(t) # Make sure that x, v, and w are either scalars or n-element vectors. # If they are scalars then we create vectors with the scalar value in # each position. if type(x) == int or type(x) == float: x = np.array([float(x)] * n) if type(v) == int or type(v) == float: v = np.array([float(v)] * n) if type(w) == int or type(w) == float: w = np.array([float(w)] * n) # Compute the stepsize. It is assumed that all elements in t are # equally spaced. h = t - t; if (n > 7): # Construct tridiagonal system; boundary conditions appear as first and # last equations in system. #A = -( 1.0 + w[1:n] * h / 2.0 ) A = - (490/(180*(h**2))) - v A[1:3] = -(2/h**2) - v[1:3] A[-3:-1] = -(2/h**2) - v[-3:-1] A = A[-1] = 1.0 B = np.zeros(n-1) for i in range(n-1): B[i] = 270/(180*(h**2)) B[0:2] = B[-3:-1] = B[-1] = 1/h**2 B[-1] = 0.0 C = B[::-1].copy() D = np.zeros(n-2) for i in range(n-2): D[i] = - (27/(180*(h**2))) D = 0.0 D[-3:-1] = D[-1] = 0.0 E = D[::-1].copy() F = np.zeros(n-3) for i in range(n-3): F[i] = 2/(180*(h**2)) F[-3:-1] = F[-1] = 0.0 G = F[::-1].copy() H = x H = a H[-1] = b ''' # Solve tridiagonal system?? How?