def test_mals(self):
"""test for MALS"""
# solve system of linear equations in matrix format
solution_mat = np.linalg.solve(self.operator_mat, self.rhs_mat)
# solve system of linear equations in TT format
solution_tt = sle.mals(self.operator_tt,
self.initial_tt,
self.rhs_tt,
repeats=1,
threshold=1e-14,
max_rank=10)
# compute relative error between exact and approximate solution
rel_err_mat = np.linalg.norm(solution_mat - solution_tt.matricize()
) / np.linalg.norm(solution_mat)
# compute relative error of the system on linear equations in TT format
rel_err_tt = (self.operator_tt @ solution_tt -
self.rhs_tt).norm() / self.rhs_tt.norm()
# check if relative errors are smaller than tolerance
self.assertLess(rel_err_mat, self.tol)
self.assertLess(rel_err_tt, self.tol)
def trapezoidal_rule(operator, initial_value, initial_guess, step_sizes, repeats=1, tt_solver='als', threshold=1e-12,
max_rank=np.infty, micro_solver='solve', normalize=1, progress=True):
"""Trapezoidal rule for linear differential equations in the TT format
Parameters
----------
operator: instance of TT class
TT operator of the differential equation
initial_value: instance of TT class
initial value of the differential equation
initial_guess: instance of TT class
initial guess for the first step
step_sizes: list of floats
step sizes for the application of the trapezoidal rule
repeats: int, optional
number of repeats of the (M)ALS in each iteration step, default is 1
tt_solver: string, optional
algorithm for solving the systems of linear equations in the TT format, default is 'als'
threshold: float, optional
threshold for reduced SVD decompositions, default is 1e-12
max_rank: int, optional
maximum rank of the solution, default is infinity
micro_solver: string, optional
algorithm for obtaining the solutions of the micro systems, can be 'solve' or 'lu', default is 'solve'
normalize: int (0, 1, or 2)
no normalization if 0, otherwise the solution is normalized in terms of Manhattan or Euclidean norm in each step
progress: bool, optional
whether to show the progress of the algorithm or not, default is True
Returns
-------
solution: list of instances of the TT class
numerical solution of the differential equation
"""
# return current time
start_time = utl.progress('Running trapezoidal rule', 0, show=progress)
# define solution
solution = [initial_value]
# define temporary tensor train
tt_tmp = initial_guess
# begin trapezoidal rule
# ----------------------
for i in range(len(step_sizes)):
# solve system of linear equations for current time step
if tt_solver == 'als':
tt_tmp = sle.als(tt.eye(operator.row_dims) - 0.5 * step_sizes[i] * operator, tt_tmp,
(tt.eye(operator.row_dims) + 0.5 * step_sizes[i] * operator).dot(solution[i]),
solver=micro_solver, repeats=repeats)
if tt_solver == 'mals':
tt_tmp = sle.mals(tt.eye(operator.row_dims) - 0.5 * step_sizes[i] * operator, tt_tmp,
(tt.eye(operator.row_dims) + 0.5 * step_sizes[i] * operator).dot(solution[i]),
solver=micro_solver, repeats=repeats, threshold=threshold, max_rank=max_rank)
# normalize solution
if normalize > 0:
tt_tmp = (1 / tt_tmp.norm(p=normalize)) * tt_tmp
# append solution
solution.append(tt_tmp.copy())
# print progress
utl.progress('Running trapezoidal rule', 100 * (i + 1) / len(step_sizes), show=progress,
cpu_time=_time.time() - start_time)
return solution
def implicit_euler(operator,
initial_value,
initial_guess,
step_sizes,
repeats=1,
tt_solver='als',
threshold=1e-12,
max_rank=np.infty,
micro_solver='solve',
progress=True):
"""Implicit Euler method for linear differential equations in the TT format
Parameters
----------
operator: instance of TT class
TT operator of the differential equation
initial_value: instance of TT class
initial value of the differential equation
initial_guess: instance of TT class
initial guess for the first step
step_sizes: list of floats
step sizes for the application of the implicit Euler method
repeats: int, optional
number of repeats of the (M)ALS in each iteration step, default is 1
tt_solver: string, optional
algorithm for solving the systems of linear equations in the TT format, default is 'als'
threshold: float, optional
threshold for reduced SVD decompositions, default is 1e-12
max_rank: int, optional
maximum rank of the solution, default is infinity
micro_solver: string, optional
algorithm for obtaining the solutions of the micro systems, can be 'solve' or 'lu', default is 'solve'
progress: bool, optional
whether to show the progress of the algorithm or not, default is True
Returns
-------
solution: list of instances of the TT class
numerical solution of the differential equation
"""
# define solution
solution = [initial_value]
# define temporary tensor train
tt_tmp = initial_guess
# begin implicit Euler method
# ---------------------------
for i in range(len(step_sizes)):
# solve system of linear equations for current time step
if tt_solver == 'als':
tt_tmp = sle.als(tt.eye(operator.row_dims) -
step_sizes[i] * operator,
tt_tmp,
solution[i],
solver=micro_solver,
repeats=repeats)
if tt_solver == 'mals':
tt_tmp = sle.mals(tt.eye(operator.row_dims) -
step_sizes[i] * operator,
tt_tmp,
solution[i],
solver=micro_solver,
threshold=threshold,
repeats=repeats,
max_rank=max_rank)
# normalize solution
tt_tmp = (1 / tt_tmp.norm(p=1)) * tt_tmp
# append solution
solution.append(tt_tmp.copy())
# print progress
if progress is True:
utl.progress('Running implicit Euler method',
100 * i / (len(step_sizes) - 1))
return solution
