An Improved Taylor Algorithm for Computing the Matrix Logarithm

Abstract

The most popular method for computing the matrix logarithm is a combination of the inverse scaling and squaring method in conjunction with a Padé approximation, sometimes accompanied by the Schur decomposition. In this work, we present a Taylor series algorithm, based on the free-transformation approach of the inverse scaling and squaring technique, that uses recent matrix polynomial formulas for evaluating the Taylor approximation of the matrix logarithm more efficiently than the Paterson–Stockmeyer method. Two MATLAB implementations of this algorithm, related to relative forward or backward error analysis, were developed and compared with different state-of-the art MATLAB functions. Numerical tests showed that the new implementations are generally more accurate than the previously available codes, with an intermediate execution time among all the codes in comparison.

1. Introduction and Notation

The calculus of matrix functions has been, for a long period of time, an area of interest in applied mathematics due to its multiple applications in many branches of science and engineering; see [1] and the references therein. Among these matrix functions, the matrix exponential stands out due to both its applications and the difficulties of its effective calculation. Basically, given a square matrix $A\in {\mathbb{C}}^{n\times n}$, its exponential function is defined by the matrix series:

$$e^A=\sum _{n\ge 0}\frac{A^n}{n!}.$$

Directly related to the exponential function, we find the matrix logarithm. Specifically, given a nonsingular matrix $A\in {\mathbb{C}}^{n\times n}$ whose eigenvalues lie in $\mathbb{C}-\left(-\infty ,0\right.$, we define the matrix logarithm of A as any matrix $X\in {\mathbb{C}}^{n\times n}$ satisfying the matrix equation:

$$A=e^X.$$

(1)

Of course, there are infinite solutions of Equation (1), but we only focus on the principal matrix logarithm or the standard branch of the logarithm, denoted by $log\left(A\right)$, which is the unique logarithm of matrix A (see Theorem 1.31 of [1]) whose eigenvalues all lie in the strip $\{z\in \mathbb{C};-\pi <Im(z)<\pi \}$. Indeed, this principal matrix logarithm is the most used in applications in many fields of research from pure science to engineering [2], such as quantum chemistry and mechanics [3,4], buckling simulation [5], biomolecular dynamics [6], machine learning [7,8,9,10], graph theory [11,12], the study of Markov chains [13], sociology [14], optics [15], mechanics [16], computer graphics [17], control theory [18], computer-aided design (CAD) [19], optimization [20], the study of viscoelastic fluids [21,22], the analysis of the topological distances between networks [23], the study of brain–machine interfaces [24], and also in statistics and data analysis [25], among other areas. Just considering various branches of engineering, the matrix logarithm can be employed to compute the time-invariant component of the state transition matrix of ordinary differential equations with periodic time-varying coefficients [26] or to recover the coefficient matrix of a differential system governed by the linear differential equation $y^{\prime }=Xy$ from observations from the state vector y [27].

The applicability of the matrix logarithm in so many distinct areas has motivated different approaches for its evaluation. One of the most-used methods was that proposed by Kenney and Laub in [28], based on the inverse scaling and squaring method and a Padé approximation, exploiting the matrix identity:

$$log\left(A\right)=2^{s}log\left(A^{1/2^s}\right).$$

(2)

This method finds an integer s such that $A^{1/2^s}$ is close to the identity matrix, approximates $log\left(A^{1/2^s}-I\right)$ by a [p/q] Padé approximation $r_{pq}\left(A\right)$, and finally, computes $2^s{r}_{pq}\left(A\right)$.

These same authors developed in [27] an algorithm that consists of obtaining the Schur decomposition $A=QT{Q}^{*}$, where Q is a unitary matrix, T is an upper triangular matrix, and $Q^{*}$ is the conjugate transpose of Q. Then, $B\approx log\left(T\right)$ is computed as follows: the main diagonal is calculated by applying the logarithm scalar function on its elements, and the upper diagonals are computed by using the Fréchet derivative of the logarithm function. Finally, $log\left(A\right)$ is computed as $QB{Q}^{*}$.

Later, most of the developed algorithms basically used the inverse scaling and squaring method with Padé approximants to dense or triangular matrices; see [29,30,31,32,33,34,35]. Nevertheless, some new algorithms are based on other methods, among which the following can be highlighted:

• An algorithm based on the arithmetic–geometric mean iteration; see [36];
• The use of contour integrals; see [37];
• Methods based on different quadrature formulas, proposed in [38,39].

Finally, we should mention the built-in MATLAB function, called logm, that computes the principal matrix logarithm by means of the algorithms described in [32,33].

Throughout this paper, we refer to the identity matrix of order n as $I_n$, or I. In addition, we denote by $\sigma \left(A\right)$ the set of eigenvalues of a matrix $A\in {\mathbb{C}}^{n\times n}$, whose spectral radius $\rho \left(A\right)$ is defined as:

$$\rho \left(A\right)=max\left\{\left|\lambda \right|;\lambda \in \sigma \left(A\right)\right\}.$$

With $\lceil x\rceil$, we denote the result reached after rounding x to the nearest integer greater than or equal to x, and $\lfloor x\rfloor$ is the result reached after rounding x to the nearest integer less than or equal to x. The matrix norm $\left|\right|·\left|\right|$ stands for any subordinate matrix norm; in particular, $\left|\right|·{\left|\right|}_1$ is the usual 1-norm. Recall that if $A=\left(a_{ij}\right)$ is a matrix in ${\mathbb{C}}^{n\times n}$, its 2-norm or Euclidean norm represented by ${∥A∥}_2$ satisfies [40]:

$$\underset{i,j}{max}\left|a_{ij}\right|\le {∥A∥}_2\le n\underset{i,j}{max}\left|a_{ij}\right|.$$

All the implemented codes in this paper are intended for IEEE double-precision arithmetic, where the unit round off is $u=2^{-53}\approx 1.11\times {10}^{-16}$. Their implementations for other distinct precisions are straightforward.

This paper is organized as follows: Section 2 describes an inverse scaling and squaring Taylor algorithm based on efficient evaluation formulas [41] to approximate the matrix logarithm, including an error analysis. Section 3 includes the results corresponding to the experiments performed in order to compare the numerical and computational performance of different codes against a test battery composed of distinct types of matrices. Finally, Section 4 presents the conclusions.

2. Taylor Approximation-Based Algorithm

If $\rho \left(A\right)<1$, then (see [1], p. 273):

$$log(I+A)=\sum _{i=1}^{\infty }{p}_i{A}^i,p_i=\frac{{(-1)}^{i+1}}{i}.$$

(3)

Taylor approximation is given by:

$$T_m\left(A\right)=\sum _{i=1}^m\frac{A^i}{i},$$

(4)

where all the coefficients are positive and m denotes the order of the approximation.

For the lower orders $m=1$, 2, and 4, the corresponding polynomial approximations from (3) use the Paterson–Stockmeyer method for the evaluation. For the Taylor approximation orders $m\ge 8$, Sastre evaluation formulas from [41,42] are used for evaluating Taylor-based polynomial approximations from (3) more efficiently than the Paterson–Stockmeyer method. For reasons that will be shown below, the Taylor approximation of $-log(I-A)$, denoted by $T_m$, is used in all the Sastre approximations and evaluation formulas of the matrix logarithm.

Sastre approximations and evaluation formulas based on (4) are denoted as $S_m^T\left(A\right)$, where the superscript stands for the type of polynomial approximation used, in this case the Taylor polynomial (4), and the subindex m represents the maximum degree of the polynomial for the corresponding polynomial approximation. Using (3) and (4), the implementation for the matrix logarithm computation is based on:

$$log(I+A)\approx -S_m^T(-A).$$

(5)

For $m=8$, we see that $S_8^T\left(A\right)=T_8\left(A\right)$. However, for higher orders of approximation, we show that $S_m^T\left(A\right)$ has some more terms than $T_m\left(A\right)$. These terms are similar to, but different from the respective ones of the Taylor series. Following [43] (Section 4), we represent this order of approach by $m+$, and its corresponding approximation is denoted by $S_{m+}^T\left(A\right)$. The next subsections deal with the different evaluation formulas and approximations.

2.1. Evaluation of $T_8\left(A\right)$

For $m=8$, the following evaluation formulas from [41] (Example 3.1) are used:

$$\begin{array}{ccc}\hfill A_2& =& A^2,\hfill \\ \hfill y_{02}\left(A\right)& =& A_2(c_4{A}_2+c_{3}A),\hfill \\ \hfill y_{12}\left(A\right)& =& ((y_{02}\left(A\right)+d_2{A}_2+d_{1}A)(y_{02}\left(A\right)+e_2{A}_2)+e_0{y}_{02}\left(A\right)\hfill \\ & & +f_2{A}_2/2+f_{1}A+f_{0}I),\hfill \end{array}$$

(6)

where the second subindex in $y_{02}\left(A\right)$ and $y_{12}\left(A\right)$ expresses the maximum power of the matrix A that appears in each expression, i.e., $A^2$. The sum of both subindices in $y_{02}\left(A\right)$ and $y_{12}\left(A\right)$ gives the cost in terms of matrix products for evaluating each formula, denoted from now on by C. Thus, $C=2$ for $y_{02}\left(A\right)$ and $C=3$ for $y_{12}\left(A\right)$.

The system of nonlinear equations to be solved in order to determine the coefficients in (6) that arise when equating $y_{12}\left(A\right)=P_8\left(A\right)$, where $P_8\left(A\right)$ is a general matrix polynomial:

$$P_8\left(A\right)=\sum _{i=0}^8{b}_i{A}^i,$$

is given by (16)–(24) of [41], i.e.,

$$\begin{array}{ccc}\hfill c_4^2{A}^8& =& b_8{A}^8,\hfill \end{array}$$

(7)

$$\begin{array}{ccc}\hfill 2c_3{c}_4{A}^7& =& b_7{A}^7,\hfill \end{array}$$

(8)

$$\begin{array}{ccc}\hfill (c_4(d_2+e_2)+c_3{c}_3)A^6& =& b_6{A}^6,\hfill \end{array}$$

(9)

$$\begin{array}{ccc}\hfill (c_4{d}_1+c_3(d_2+e_2))A^5& =& b_5{A}^5,\hfill \end{array}$$

(10)

$$\begin{array}{ccc}\hfill (d_2{e}_2+c_3{d}_1+c_4{e}_0)A^4& =& b_4{A}^4,\hfill \end{array}$$

(11)

$$\begin{array}{ccc}\hfill (d_1{e}_2+c_3{e}_0)A^3& =& b_3{A}^3,\hfill \end{array}$$

(12)

$$\begin{array}{ccc}\hfill f_2{A}^2& =& b_2{A}^2,\hfill \end{array}$$

(13)

$$\begin{array}{ccc}\hfill f_{1}A& =& b_{1}A,\hfill \end{array}$$

(14)

$$\begin{array}{ccc}\hfill f_{0}I& =& b_{0}I.\hfill \end{array}$$

(15)

From (7), one obtains $c_4=\pm \sqrt{b_8}$. Since $p_8=-1/8$ in (3), we equate $y_{12}\left(A\right)=T_8\left(A\right)$ from (4), where the corresponding coefficient is positive to prevent $c_4$ from being a complex number.

This system can be solved analytically using (25)–(32) from [41] (Example 3.1), giving four sets of exact solutions for the coefficients in (6). Then, the solutions are rounded to the desired precision arithmetic. As mentioned before, we use IEEE double-precision arithmetic. From now on, for any coefficient $x_i$, ${\tilde{x}}_i$ denotes the corresponding one rounded to that precision.

In order to check if the rounded coefficient solutions are sufficiently accurate to evaluate (6), we follow the stability check of [41] (Example 3.1). It consists of substituting the rounded coefficients into the original system of Equations (7)–(15) and testing if the relative error given by them with respect to each coefficient $b_i$, for $i=0,1,\dots ,8$, is lower than the unit round off in IEEE double-precision arithmetic. For instance, from (12), it follows that the relative error for $b_3$ is:

$$|b_3-({\tilde{d}}_1{\tilde{e}}_2+{\tilde{c}}_3{\tilde{e}}_0)|/|b_3|.$$

(16)

Then, we select a set of solutions where the relative errors for all $b_i$, for $i=0,1,\dots ,8$, are lower than u. In our experience, solutions giving relative errors of order $O\left(u\right)$ also provide accurate results. Finally, the approximation is computed as:

$$log(I+A)\approx -T_8(-A)=-y_{12}(-A)=-S_8^T(-A),$$

(17)

where $-S_8^T(-A)$ is evaluated using (6) with the coefficients from

Table 1. Coefficients for computing the matrix logarithm Taylor approximation of order $m=8$, using Sastre evaluation Formula (6), as $log(I+A)\approx -S_8^T(-A)=-y_{12}(-A)=-T_8(-A)$.

$c_4$	$\phantom{-}3.535533905932738\times {10}^{-1}$
$c_3$	$\phantom{-}2.020305089104422\times {10}^{-1}$
$d_2$	$-1.575975261945013\times {10}^{-1}$
$d_1$	$\phantom{-}3.622805588353235\times {10}^{-1}$
$e_2$	$\phantom{-}5.135560418938517\times {10}^{-1}$
$e_0$	$\phantom{-}7.290085258759625\times {10}^{-1}$
$f_2$	$1/2$
$f_1$	1
$f_0$	0

.

2.2. Evaluation of Higher-Order Taylor-Based Approximations

For higher orders of approximation, we followed a similar procedure as that described in [43] (Sections 3.2 and 3.3), where evaluation formulas for Taylor-based approximations of the matrix exponential of orders $m=15+$ and $21+$ were given. Both of these formulas were generalized to any polynomial approximation in [42] (Section 3), and this type of polynomial approximation evaluation formula was first presented in [41] (Example 5.1). Following the notation given in [43] (Section 4), the suffix “+” in m means that the corresponding Taylor-based approximation is more accurate than the Taylor one of order m. This is because the approximation with the order denoted by $m+$ has some more polynomial terms than the Taylor one of order m, and these terms are similar to the corresponding Taylor approach terms. We numerically define this similarity in each case.

Proposition 1 and the MATLAB code fragments from [42] (Section 3.1) allow obtaining all the solutions for the coefficients of the evaluation formulas (10)–(12) from [43] (Section 3.2), not only for the exponential Taylor approximation of order $m=15+$, but for whatever polynomial approximation of the same order. Unfortunately, there were no real solutions for the evaluation formulas of the logarithm Taylor approximation of order $m=15+$. We also tested different variations of the formulas providing order $m=15+$; however, there were no real solutions for any of them. The same also occurred in [44] (Section 2.2) with the hyperbolic tangent Taylor approximation of order $m=15+$. In that case, we could find real solutions using an approximation of order $m=14+$. In this case, there were also real solutions for the following logarithm Taylor approximation evaluation formulas of order $m=14+$:

$$\begin{array}{ccc}\hfill y_{02}\left(A\right)& =& A_2(c_1{A}_2+c_{2}A),\hfill \\ \hfill y_{12}\left(A\right)& =& (y_{02}\left(A\right)+c_3{A}_2+c_{4}A)(y_{02}\left(A\right)+c_5{A}_2)+c_6{y}_{02}\left(A\right),\hfill \\ \hfill y_{22}\left(A\right)& =& A((y_{12}\left(A\right)+c_7{y}_{02}\left(A\right)+c_8{A}_2+c_{9}A)(y_{12}\left(A\right)+c_{10}{A}_2+c_{11}A)\hfill \\ & & +c_{12}{y}_{12}\left(A\right)+c_{13}{A}_2+c_{14}A+c_{15}I),\hfill \end{array}$$

(18)

where it is easy to show that the degree of $y_{22}\left(A\right)$ is 16. Therefore, we denote this approximation by $S_{14+}^T\left(A\right)$, and similarly to [44] (Section 2.2), one obtains:

$$S_{14+}^T\left(A\right)=y_{22}\left(A\right)=T_{14}+b_{15}{A}^{15}+b_{16}{A}^{16},$$

(19)

where $T_{14}\left(A\right)$ is given by (4) and $b_{15}$ and $b_{16}$ depend on the coefficients $c_i$ from (18). From (4), one obtains that $p_{15}=1/15$ and $p_{16}=1/16$. From all the solutions obtained for the coefficients, a stable one was selected that incurs in relative errors lower than one with respect to the corresponding Taylor coefficients $p_{15}$ and $p_{16}$, concretely:

$$\begin{array}{ccc}\hfill \left|\right(b_{15}-1/15\left)15\right|& =& 0.42,\hfill \\ \hfill \left|\right(b_{16}-1/16\left)16\right|& =& 0.87,\hfill \end{array}$$

(20)

showing two decimal digits.

For orders from $m=21+$ to $m=39+$, we first evaluate and store the matrix powers $A_i=A^i$ for $i=2,3,\dots ,s$, and then, the evaluation formulas (94)–(96) proposed in [42] (p. 21) are used, reproduced here for the sake of clarity:

$$\begin{array}{ccc}\hfill y_{0s}\left(A\right)& =& A_s{\displaystyle \sum _{i=1}^s}{c}_i{A}_i,\hfill \end{array}$$

(21)

$$\begin{array}{ccc}\hfill y_{1s}\left(A\right)& =& {\displaystyle \sum _{i=s+1}^{4s}}{a}_i{A}^i\hfill \\ & =& \left(y_{0s}\left(A\right)+{\displaystyle \sum _{i=1}^s}{d}_i{A}_i\right)\left(y_{0s}\left(A\right)+{\displaystyle \sum _{i=2}^s}{e}_i{A}_i\right)\hfill \end{array}$$

(22)

$$\begin{array}{ccc}& & +f_0{y}_{0s}\left(A\right)+{\displaystyle \sum _{i=3}^s}{f}_i{A}_i,\hfill \end{array}$$

(23)

$$\begin{array}{ccc}\hfill y_{2s}\left(A\right)& =& \left(y_{1s}\left(A\right)+{\displaystyle \sum _{i=1}^s}{g}_i{A}_i\right)\left(y_{1s}\left(A\right)+h_0{y}_{0s}\left(A\right)+{\displaystyle \sum _{i=1}^s}{h}_i{A}_i\right)\hfill \\ & & +j_0{y}_{1s}\left(A\right)+k_0{y}_{0s}\left(A\right)+{\displaystyle \sum _{i=0}^s}{l}_i{A}_i.\hfill \end{array}$$

(24)

The degree of $y_{2s}\left(A\right)$ is $8s$, and the total number of coefficients of $y_{2s}\left(A\right)$ is $6s+4$, i.e., $3s$ coefficients $a_i$, s coefficients $g_i$, s coefficients $h_i$, $s+1$ coefficients $l_i$, and coefficients $f_0$, $j_0$, and $k_0$; see [42] (p. 21). Analogous to (6), the cost C for evaluating $y_{ks}\left(A\right)$, $k=0,1,2$, from (21), (23) and (24) in terms of the matrix products is $C=k+s$.

Again, the corresponding approximation from (24), denoted as $S_{(6s+3)+}^T\left(A\right)=y_{2s}\left(A\right)$, allows us to evaluate Taylor-based approximations of the matrix logarithm of the type:

$$S_{(6s+3)+}^T\left(A\right)=y_{2s}\left(A\right)=T_{6s+3}+\sum _{i=6s+4}^{8s}{b}_i{A}^i,$$

(25)

where the coefficients $b_i$ depend on the ones from (21)–(24).

In order to obtain all coefficients from these expressions, the nested procedure used in [43] (Sections 3.2 and 3.3) was applied. Analogous to [44] (p. 7), we employed the vpasolve function from the MATLAB Symbolic Computation Toolbox (https://es.mathworks.com/help/symbolic/vpasolve.html, accessed on 20 August 2021) with the random option to obtain different solutions of the nonlinear system arising for each order of approximation. Concretely, we obtained 1000 solutions for the coefficient sets of (21), (22), and (24) for orders $m=21+$ and $m=27+$ and 300 solutions for $m>27+$. Then, the most stable real solution according to the stability check from [41] (Example 3.1) (see (16)) was selected for each order $m+$.

Similar to (20), we checked that the relative error for coefficients $b_i$, $i=6s+4$, $6s+5,\dots ,8s$ from (27) with respect to the corresponding Taylor coefficients for the selected solutions was less than one.

For the orders higher than $m=39+$, we combined $y_{2s}\left(A\right)$ from (24) with the Paterson–Stockmeyer method, similar to (52) from [41] (Proposition 1), giving:

$$\begin{array}{ccc}\hfill z_{2ps}\left(A\right)& =& \left(\left(\cdots \left(y_{2s}\left(A\right)A^s+a_{p-1}{A}^{s-1}+a_{p-2}{A}^{s-2}+\dots +a_{p-s+1}A+a_{p-s}\right)\right.\right.\hfill \\ & \times & \left.A^s+a_{p-s-1}{A}^{s-1}+a_{p-s-2}{A}^{s-2}+\dots +a_{p-2s+1}A+a_{p-2s}\right)\hfill \\ & \times & \left.A^s+a_{p-2s-1}{A}^{s-1}+a_{p-2s-2}{A}^{s-2}+\dots +a_{p-3s+1}A+a_{p-3s}\right)\hfill \\ & & ⋮\hfill \\ & \times & A^s+a_{s-1}{A}^{s-1}+a_{s-2}{A}^{s-2}+\dots +a_{1}A+a_{0}I,\hfill \end{array}$$

(26)

where p is a multiple of s and the resulting Taylor-based approximation order is $m=(6s+3+p)+$. If $p=0$, note that $z_{2ps}\left(A\right)=y_{2s}\left(A\right)$. Therefore, the corresponding approximation (26) is denoted by $S_{(6s+3+p)+}^T\left(A\right)$, and it allows us to evaluate Taylor-based approximations of the matrix logarithm of the type:

$$S_{(6s+3+p)+}^T\left(A\right)=z_{2ps}\left(A\right)=T_{6s+3+p}\left(A\right)+\sum _{i=6s+4+p}^{8s+p}{b}_i{A}^i.$$

(27)

Table 2. Maximum available approximation order for a cost C in terms of matrix products using the Paterson–Stockmeyer method, denoted by $d_{PS}$, the maximum order using $S_{(6s+3+p)+}^T\left(A\right)$ from (27), denoted by $d_{z_{S^T}}$, and the difference $d_{z_{S^T}}-d_{PS}$. Parameters s and p are used in $z_{S^T}\left(A\right)$ in each case.

C	3	4	5	6	7	8	9	10	11	12	13
$d_{PS}$	6	9	12	16	20	25	30	36	42	49	56
$d_{z_{2ps}}$	-	15+	21+	27+	33+	39+	45+	52+	59+	67+	75+
$d_{z_{2ps}}-d_{PS}$	-	6	9	11	13	14	15	16	17	18	19
s	-	2	3	4	5	6	6	7	7	8	8
p	-	0	0	0	0	0	6	7	14	16	24

shows the orders of approximations available using the Paterson–Stockmeyer method or $S_{(6s+3+p)+}^T\left(A\right)$ and their differences for a given cost C in terms of matrix products. It also shows the corresponding values of s and p for (26). Table 2 shows that the difference in the polynomial orders increases as C grows. See the function available at http://personales.upv.es/~jorsasma/Software/logm_pol.m for implementation details (accessed on 20 August 2021).

2.3. Error Analysis

On the one hand, the relative forward error of approximating $log(I+A)$ by means of $S_m^T\left(A\right)$ can be defined as:

$$E_{rf}\left(A\right)=∥log{(I+A)}^{-1}\left(log(I+A)+S_m^T(-A)\right)∥,$$

where $S_m^T\left(A\right)$ is any of the Sastre approximations that appear in Section 2.1 and Section 2.2. This error can be expressed as:

$$E_{rf}\left(A\right)=\sum _{k\ge m}{a}_k{A}^k.$$

Using Theorem 1.1 from [45], one obtains:

$$E_{rf}\left(A\right)=∥\sum _{k\ge m}{a}_k{A}^k∥\le \sum _{k\ge m}\left|a_k\right|{\alpha }_m^k\equiv h_m\left({\alpha }_m\right),$$

(28)

where:

$${\alpha }_m=max\left\{\left|\right|A^k|{|}^{1/k}:k⩾m\right\}.$$

(29)

Let ${\mathsf{\Theta }}_m$ be:

$${\mathsf{\Theta }}_m=max\left\{\theta \ge 0:h_m\left(\theta \right)\le u\right\}.$$

(30)

On the other hand, the absolute backward error can be defined as the matrix $\mathsf{\Delta }A$ that verifies:

$$log\left(I+A+\mathsf{\Delta }A\right)=-S_m^T(-A).$$

Then:

$$I+A+\mathsf{\Delta }A=e^{-S_m^T(-A)},$$

whereby the backward error can be expressed as:

$$\mathsf{\Delta }A=e^{-S_m^T(-A)}-I-A.$$

It can be proven that this error can be expressed as ${\displaystyle \sum _{k\ge m+1}}{b}_k{A}^k$; hence, the relative backward error of approximating $log(I+A)$ by means of $-S_m^T(-A)$ can be bounded as follows:

$$E_{rb}\left(A\right)=\frac{∥{\displaystyle \sum _{k\ge m+1}}{b}_k{A}^k∥}{∥A∥}=∥\sum _{k\ge m+1}{b}_k{A}^{k-1}∥=∥\sum _{k\ge m}{\overline{b}}_k{A}^k∥\le \sum _{k\ge m}\left|{\overline{b}}_k\right|{\alpha }_m^k\equiv {\overline{h}}_m\left({\alpha }_m\right),$$

(31)

where ${\overline{b}}_k=b_{k+1}.$

Let ${\overline{\mathsf{\Theta }}}_m$ be:

$${\overline{\mathsf{\Theta }}}_m=max\left\{\theta \ge 0:{\overline{h}}_m\left(\theta \right)\le u\right\}.$$

(32)

The values of ${\mathsf{\Theta }}_{m_k}$ and ${\overline{\mathsf{\Theta }}}_{m_k}$, listed in

Table 3. Values ${\mathsf{\Theta }}_{m_k}$ and ${\overline{\mathsf{\Theta }}}_{m_k}$, $1\le k\le 13$, corresponding to the forward and backward error analyses, respectively.

	${\mathsf{\Theta }}_{{\mathit{m}}_{\mathit{k}}}$	${\overline{\mathsf{\Theta }}}_{{\mathit{m}}_{\mathit{k}}}$
$m_1=2$	$1.825012070831092\times {10}^{-8}$	$1.825012070831092\times {10}^{-8}$
$m_2=4$	$1.534933282031150\times {10}^{-4}$	$1.534943099234865\times {10}^{-4}$
$m_3=8$	$1.332493973299263\times {10}^{-2}$	$1.333163669910284\times {10}^{-2}$
$m_4=14+$	$9.274127959683863\times {10}^{-2}$	$9.306363354613097\times {10}^{-2}$
$m_5=21+$	$2.098941946985260\times {10}^{-1}$	$2.110800698278637\times {10}^{-1}$
$m_6=27+$	$2.939884229988359\times {10}^{-1}$	$2.955066872745040\times {10}^{-1}$
$m_7=33+$	$3.708207838275638\times {10}^{-1}$	$3.727263249913135\times {10}^{-1}$
$m_8=39+$	$4.262026331818284\times {10}^{-1}$	$4.280874011090428\times {10}^{-1}$
$m_9=45+$	$4.859152511361255\times {10}^{-1}$	$4.896983924717211\times {10}^{-1}$
$m_{10}=52+$	$5.370288954119011\times {10}^{-1}$	$5.40947981059669\times {10}^{-1}$
$m_{11}=59+$	$5.782443740143352\times {10}^{-1}$	$5.82425847124017\times {10}^{-1}$
$m_{12}=67+$	$6.172435921175158\times {10}^{-1}$	$6.17751273400193\times {10}^{-1}$
$m_{13}=75+$	$6.518700502072328\times {10}^{-1}$	$6.53999314510431\times {10}^{-1}$

, were obtained by using symbolic computations. They satisfy that ${\mathsf{\Theta }}_{m_k}\approx {\overline{\mathsf{\Theta }}}_{m_k}$ and ${\mathsf{\Theta }}_{m_k}<{\overline{\mathsf{\Theta }}}_{m_k}$, for $k\in \left\{1,2,\cdots ,13\right\}$. Hence, the numerical performance of two different algorithms, each based on one of these error formulations, will be very similar. Taking into account (28) and (30)–(32), if ${\alpha }_m\le {\mathsf{\Theta }}_m$, then:

$$E_{rf}\left(A\right)\le h_m\left({\alpha }_m\right)\le h_m\left({\mathsf{\Theta }}_m\right)\le u,$$

(33)

and:

$$E_{rb}\left(A\right)\le {\overline{h}}_m\left({\alpha }_m\right)\le {\overline{h}}_m\left({\overline{\mathsf{\Theta }}}_m\right)\le u,$$

(34)

i.e., the relative forward and backward errors are lower than the unit round off in IEEE double-precision arithmetic.

However, if only ${\alpha }_m\le {\overline{\mathsf{\Theta }}}_m$, then:

$$E_{rb}\left(A\right)\le {\overline{h}}_m\left({\alpha }_m\right)\le {\overline{h}}_m\left({\overline{\mathsf{\Theta }}}_m\right)\le u,$$

(35)

i.e., only the relative backward error is lower than the unit round off.

2.4. Algorithm for Computing $log\left(A\right)$

Taking into account that $log\left(A\right)$ can be expressed as $log(I+A-I)$, Algorithm 1 computes $log\left(A\right)$ by the inverse scaling and squaring Taylor algorithm based on the expressions that appear in Section 2.1 and Section 2.2, where $m_k$, $k\in \left\{1,2,\cdots ,13\right\}$, is a Taylor approximation order. In this algorithm, we can use either the ${\mathsf{\Theta }}_k$ (forward error analysis) or the ${\overline{\mathsf{\Theta }}}_k$ (backward error analysis) of Table 3.

The preprocessing step is based on applying a similarity transformation of matrix A to obtain a permutation of a diagonal matrix T whose elements are integer powers of two and a new balanced matrix B such that $B=T^{-1}AT$. The aim of balancing is to achieve the norms of each row of B and its corresponding column nearly equal, trying to concentrate any ill-conditioning of the eigenvalues of matrix A into the diagonal scaling matrix T. To carry out this balancing, the balance MATLAB function can be employed.

Steps 2 to 11 bring A close to I by taking successive square roots of A until $\alpha \le {\mathsf{\Theta }}_{m_k}$, where $m_k$ is the maximum order and $\alpha$ is computed as described in Step 5. To compute the matrix square roots required, we implemented a MATLAB function that uses the scaled Denman–Beavers iteration described in [1] (Equation (6.28)). This iteration is defined by:

$$\begin{array}{c}\hfill \begin{array}{c}\hfill X_{k+1}=\frac{1}{2}({\mu }_k{X}_k+{\mu }_k^{-1}{Y}_k^{-1}),\\ \hfill Y_{k+1}=\frac{1}{2}({\mu }_k{Y}_k+{\mu }_k^{-1}{X}_k^{-1}),\end{array}\end{array}$$

(36)

with $X_0=A$, $Y_0=I$, and ${\mu }_k={|det\left(X_k\right)det\left(Y_k\right)|}^{-1/\left(2n\right)}$, n being the dimension of matrix A. Although convergence is not guaranteed, if it does, then $X_k$ converges to $A^{1/2}$. In Step 5, we use the following approximation for calculating $\alpha$ from (29) (see [46,47]):

$$\alpha \approx max\left\{\right|\left|{(A-I)}^{m_k}\right|{|}^{1/m_k},\left|\right|{(A-I)}^{m_k+1}\left|{|}^{1/(m_k+1)}\right\}.$$

To compute approximately the 1-norm of ${\left|\right|(A-I)}_k^m\left|\right|$ and ${\left|\right|(A-I)}^{m_k+1}\left|\right|$, the 1-norm estimation algorithm of [48] can be employed. In order to implement Algorithm 1 in the most efficient way, it is worth noting that ${\left|\right|(A-I)}^{m_k+1}{\left|\right|}^{1/(m_k+1)}$ should be only worked out if ${\left|\right|(A-I)}^{m_k}{\left|\right|}^{1/m_k}\le {\mathsf{\Theta }}_{m_k}$.

Algorithm 1 Given a matrix $A\in {\mathbb{C}}^{n\times n}$, a maximum approximation order $m_k$, $k\in \left\{1,2,3,\cdots ,13\right\}$, and a maximum number of iterations $maxiter$, this algorithm computes $L=log\left(A\right)$ by a Taylor approximation of order lower that or equal to $m_k$.

1: Preprocessing of matrix A: $A\leftarrow T^{-1}AT$ 2: $s=0$ 3: $finish=\left|\right|A-I\left|\right|\le {\mathsf{\Theta }}_{m_k}$ 4: while not$finish$ and $s<maxiter$ do 5:     $\alpha =max\left\{\right|\left|{(A-I)}^{m_k}\right|{|}^{1/m_k},\left|\right|{(A-I)}^{m_k+1}\left|{|}^{1/(m_k+1)}\right\}$ 6:     $finish=\alpha \le {\mathsf{\Theta }}_{m_k}$ 7:     if not $finish$ then 8:         $A\leftarrow A^{1/2}$, using scaled DB iteration (36) 9:         $s=s+1$ 10:     end if 11: end while 12: Find the smallest integer $\overline{k}\le k$ such that $\alpha \le {\mathsf{\Theta }}_{m_{\overline{k}}}$ 13: Compute $L=T_{m_{\overline{k}}}(A-I)$, using the expressions that appear in Section 2.1 and Section 2.2. 14: $L\leftarrow 2^{s}L$ 15: Postprocessing of matrix L: $L\leftarrow TL{T}^{-1}$

Then, Step 12 finds the most appropriate order of the approximation polynomial to be used, always with the aim of reducing the computational cost, but without any loss of accuracy. For efficiency reasons, an algorithm based on the well-known bisection method of function root search was adopted. In Step 13, the matrix logarithm approximation of $A-I$ is computed by means of the efficient polynomial evaluations presented in Section 2.1 and Section 2.2. Finally, the squaring phase takes place in Step 14, and in Step 15, the postprocessing operation $L=TL{T}^{-1}$ is required to provide the logarithm of matrix A if the preprocessing stage was previously applied to it.

3. Numerical Experiments

In this section, we compare the following five MATLAB codes in terms of accuracy and efficiency:

• logm_iss_full: It calculates the matrix logarithm using the transformation-free form of the inverse scaling and squaring method with Padé approximation. Matrix square roots are computed by the product form of the Denman–Beavers iteration ([1], Equation (6.29)). It corresponds to Algorithm 5.2 described in [32], denoted as the iss_new code;
• logm_new: It starts with the transformation of the input matrix A to the Schur triangular form $A=QT{Q}^{*}$. Thereafter, it computes the logarithm of the triangular matrix T using the inverse scaling and squaring method with Padé approximation. The square roots of the upper triangular matrix T are computed by the Björck and Hammarling algorithm ([1,49], Equation (6.3)), solving one column at a time. It is an implementation of Algorithm 4.1 explained in [32], designated as the iss_schur_new function;
• logm: It is a MATLAB built-in function in charge of working out the matrix logarithm from the algorithms included in [32,33]. MATLAB R2015b incorporated an improved version that applies inverse scaling and squaring and Padé approximants to the whole triangular Schur factor, whereas the previous logm applied this technique to the individual diagonal blocks in conjunction with the Parlett recurrence. Although it follows a similar main scheme to the logm_new code, the square roots of the upper triangular matrix T are computed using a recursive blocking technique from the Björck and Hammarling recurrence, which works outs the square roots of increasingly smaller triangular matrices [50]. The technique is rich on matrix multiplications and has the requirement of solving the Sylvester equation. In addition, it allows parallel architectures to be exploited simply by using threaded BLAS;
• logm_polf: This is an implementation of Algorithm 1, where Taylor matrix polynomials are evaluated thanks to the Sastre formulas previously detailed. Values from the set $m\in \left\{2,4,8,14+,21+,27+,33+,39+,45+,52+,59+,67+,75+\right\}$ were used as the approximation polynomial order for all the tests carried out in this section, and forward relative errors were considered;
• logm_polb: It is an identical implementation to the previous code, but it is based on relative backward errors.

A testbed consisting of the following three sets of different matrices was employed in all the numerical experiments performed. In addition, MATLAB Symbolic Math Toolbox with 256 digits of precision was the tool chosen to obtain the “exact”matrix logarithm, using the vpa (variable-precision floating-point arithmetic) function:

• Set 1: The 100 diagonalizable $128\times 128$ complex matrices. They have the form $A=V\times D\times V^T$, where D is a diagonal matrix with complex eigenvalues and V is an orthogonal matrix such as $V=H/\sqrt{n}$, H being a Hadamard matrix and n the matrix order. The 2-norm of these matrices varies from $0.1$ to 300. The “exact”matrix logarithm was calculated as $log\left(A\right)=V\times log\left(D\right)\times V^T$;
• Set 2: The 100 nondiagonalizable $128\times 128$ complex matrices computed as $A=V\times J\times V^T$, where J is a Jordan matrix with complex eigenvalues whose algebraic multiplicity is randomly generated between 1 and 3. V is an orthogonal random matrix with elements in progressively wider intervals from $[-2.5,2.5]$, for the first matrix, to $[-250,250]$, for the last one. As the 2-norm, these matrices range from $3.39$ to $337.72$. The “exact”matrix logarithm was computed as $log\left(A\right)=V\times log\left(J\right)\times V^T$;
• Set 3: The 52 matrices A from the Matrix Computation Toolbox (MCT) [51] and the 20 from the Eigtool MATLAB Package (EMP) [52], all of them with a $128\times 128$ order. The “exact”matrix logarithm was calculated by means of the following three-step procedure:
  • Calling the MATLAB function eig and providing, as a result, a matrix V and a diagonal matrix D such that $A=V\times D\times V^{-1}$, using the vpa function. If any of the elements of matrix D, i.e., the eigenvalues of matrix A, have a real value less than or equal to zero, this will be replaced by the result of the sum of its absolute value and a random number in the interval $[0,1]$. Thus, a new matrix $\tilde{D}$ will be generated. Next, matrices $\tilde{A}$ and $L_1$ will be calculated in the form $\tilde{A}=V\times \tilde{D}\times V^{-1}$ and $L_1=V\times log\left(\tilde{D}\right)\times V^{-1}$;
  • Computing the matrix logarithm thanks to the logm and vpa functions, that is $L_2=logm\left(\tilde{A}\right)$;
  • Considering the “exact”matrix logarithm of $\tilde{A}$ only if:

    $$\frac{∥L_1-L_2∥}{∥L_1∥}<u.$$
  A total of forty-six matrices, forty from the MCT and six from the EMP, were considered for the numerical experiments. The others were excluded for the following reasons:

  -

  Matrices 17, 18, and 40 from the MCT and Matrices 7, 9, and 14 from the EMP did not pass the previous procedure for the “exact”matrix logarithm computation;

  -

  The relative error incurred by some of the codes in comparison was greater than or equal to unity for Matrices 4, 6, 12, 26, 35, and 38 belonging to the MCT and Matrices 1, 4, 10, 19, and 20 pertaining to the EMP. The reason was the ill-conditioning of these matrices for the matrix logarithm function;

  -

  Matrices 2, 9, and 16, which are part of the MCT, and Matrices 15 and 18, incorporated in the EMP, resulted in a failure to execute the logm_iss_full code. More specifically, the error was due to the fact that the function sqrtm_dbp, responsible for computing the principal square root of a matrix using the product form of the Denman–Beavers iteration, did not converge after a maximum allowed number of 25 iterations;

  -

  Matrices 8, 11, 13, and 16 from the EMP were already incorporated in the MCT.

  If we had not taken the previously described precaution of modifying all those matrices with eigenvalues less than or equal to zero, they would have been directly discarded, and evidently, the number of matrices that would be part of this set would be much more reduced.

The accuracy of the distinct codes for each matrix A was tested by computing the normwise relative error as:

$$\mathrm{Er}\left(\mathrm{A}\right)=\frac{\parallel log\left(A\right)-\widetilde{log}{\left(A\right)\parallel }_2}{{∥log\left(A\right)∥}_2},$$

where $log\left(A\right)$ means the “exact”solution and $\widetilde{log}\left(A\right)$ denotes the approximate one. All the tests were carried out on a Microsoft Windows 10 ×64 PC system with an Intel Core i7-6700HQ CPU @2.60Ghz processor and 16 GB of RAM, using MATLAB R2020b.

First of all, three experiments were performed, one for each of the three above sets of matrices, respectively, in order to evaluate the influence of the type of error employed by comparing the numerical and computational performance of logm_polf and logm_polb.

Table 4. Relative error comparison, for the three sets of matrices, between logm_polf and logm_polb.

	Set 1	Set 2	Set 3
Er(logm_polf)<Er(logm_polb)	3%	0%	2.17%
Er(logm_polf)>Er(logm_polb)	0%	0%	0%
Er(logm_polf)=Er(logm_polb)	97%	100%	97.83%

shows the percentage of cases in which the normwise relative error of logm_polf was lower, greater than, or equal to that of logm_polb. As expected, according to the $\mathsf{\Theta }$ and $\overline{\mathsf{\Theta }}$ values exposed in Table 3, both codes gave almost identical results, with a practically inappreciable improvement for logm_polf in the case of Sets 1 and 3.

The computational cost of logm_polf and logm_polb was basically identical, although slightly lower in the case of the latter code, since the logm_polb function required, on some cases, approximation polynomials of lower orders than those of logm_polf. Both of them performed an identical number of matrix square roots.

After analyzing these results, we can conclude that there are no significant differences between the two codes, and either of them could be used in the remainder of this section to establish a comparison with the other ones. Be that as it may, the code chosen to be used for this purpose was logm_polf, and from here on, we designate it as logm_pol, a decision justified by its numerical and computational equivalence to logm_polb.

Having decided which code based on the Taylor approximation to use, we now assess its numerical peculiarities and those of the other methods for our test battery.

Table 5. Relative error comparison, for the three sets of matrices, of logm_pol versus logm_iss_full, logm_new, and logm.

	Set 1	Set 2	Set 3
Er(logm_pol)<Er(logm_iss_full)	100%	100%	97.83%
Er(logm_pol)>Er(logm_iss_full)	0%	0%	2.17%
Er(logm_pol)=Er(logm_iss_full)	0%	0%	0%
Er(logm_pol)<Er(logm_new)	97%	89%	89.13%
Er(logm_pol)>Er(logm_new)	3%	11%	10.87%
Er(logm_pol)=Er(logm_new)	0%	0%	0%
Er(logm_pol)<Er(logm)	97%	89%	89.13%
Er(logm_pol)>Er(logm)	3%	11%	10.87%
Er(logm_pol)=Er(logm)	0%	0%	0%

sets out a comparison, in percentage terms, of the relative errors incurred by logm_pol with respect to logm_iss_full, logm_new, and logm.

As we can see, logm_pol outperformed logm_iss_full in accuracy in 100% of the matrices in Sets 1 and 2 and 97.83% of them in Set 3. logm_pol achieved better accuracy than logm_new and logm in 97%, 89%, and 89.13% of the matrices for Sets 1, 2, and 3, respectively.

Graphically, Figure 1, Figure 2 and Figure 3 provide the results obtained according to the experiments carried out for each of the sets of matrices. More in detail, the normwise relative errors (a), the performance profiles (b), the ratio of the relative errors (c), the lowest and highest relative error rates (d), the polynomial or diagonal Padé orders (e), the execution times (f), and the ratio of the execution times (g) for the four codes analyzed can be appreciated.

Figure 1a, Figure 2a and Figure 3a illustrate the normwise relative errors assumed by each of the codes when calculating the logarithm of the different matrices that comprise each of the sets. The solid line that appears in them depicts the function $k_{log}u$, where $k_{log}$ (or $cond$) represents the condition number of the matrix logarithm function ([1], Chapter 3) and u is the unit round off. The numerical stability of each method is evidenced if its errors are not much higher than this solid line. The matrices were ordered by decreasing value of $cond$.

Roughly speaking, logm_pol obtained the lowest error values for most of the test matrices, whereas the top values corresponded to logm_iss_full, for Sets 1 and 2, or to logm_new and logm, for Set 3. Indeed, in the case of the first two sets, the vast majority of errors incurred by logm_pol are below the continuous line, while those of logm_new and logm are around this line and, in the case of logm_iss_full, clearly above it. The results provided by logm_new and logm were identical in the different experiments performed, with the exception of Set 3, where they were very similar. With regard to Set 3, the high condition number of the logarithm function for some test matrices meant that the maximum relative error committed by logm_pol punctually reached in one case the order of ${10}^{-3}$, closely followed by the error recorded by logm_iss_full. Nevertheless, for this third set of matrices and except for a few concrete exceptions, all methods provided results whose errors are usually located below the $k_{log}u$ line.

Accordingly, these results showed that the numerical methods, on which the different codes were based, are stable, especially in the case of Taylor and its implementation in the logm_pol function, whose relative errors, as mentioned before, are always positioned in lowest positions on the graphs, thus delivering excellent results. It should be clarified that Matrices 19, 21, 23, 27, 51, and 52 from the MCT and Matrix 17 from the EMP are not plotted in Figure 3a because of the excessive condition number of the logarithm function, although it was taken into account in all other results.

Figure 1b, Figure 2b and Figure 3b trace the performance profile of the four codes where, on the x-axis, $\alpha$ takes values from 1–5 with increments of 0.1. Given a specific value for the $\alpha$ coordinate, the corresponding amount p on the y-axis denotes the probability that the relative error committed by a particular algorithm is less than or equal to $\alpha$-times the smallest relative error incurred by all of them.

In consonance with the results given in Table 5, the performance profiles showed that logm_pol was the most accurate function for the three matrix sets. In the case of the matrices belonging to the first two sets, the probability reached practically 100% in most of the figures, while it tended to be around 95% for the matrices that comprised the third set. Regarding the other codes, logm_new and logm offered practically identical results in accuracy, with a few more noticeable differences in the initial part of Figure 3b in favor of logm_new. On the other hand, logm_iss_full was significantly surpassed by logm_new and logm in Sets 1 and 2, with the opposite being true for Set 3, although in a more discrete manner.

The ratios in the normwise relative errors between logm_pol and the other tested codes are presented, in decreasing order according to Er(logm_iss_full)/Er(logm_pol), in Figure 1c, Figure 2c and Figure 3c. For the vast majority of the matrices in Sets 1 and 2, the values plotted are always greater than one, which again confirmed the superiority in terms of accuracy of logm_pol over the other codes, especially for logm_iss_full. Similar conclusions can be extracted from the analysis of the results for Set 3, although, in this case, the improvement of logm_pol was more remarkable over logm_new and logm for a small group of matrices.

In the form of a pie chart, the percentage of matrices in our test battery in which each method yielded the smallest or the largest normwise relative error over the other three ones is displayed in Figure 1d, Figure 2d and Figure 3d. Thus, on the positive side, logm_pol resulted in the lowest error in 94%, 86%, and 89% of the cases for, respectively, each of the matrix sets. Additionally, logm_pol never gave the most inaccurate result in the first two matrix sets and only gave the worst result in 2% of the matrices in Set 3. As can be seen, logm_iss_full gave the highest relative errors in 94% and 88% of the matrices correspondingly belonging to Set 1 and Set 2. On the contrary, the highest error rates were shared between logm_new and logm in Set 3.

The value of parameter m, or, in other words, the Taylor approximation polynomial order, in the case of logm_pol, or the Padé approximant degree, in the case of logm_iss_full, logm_new, and logm, is shown in Figure 1e, Figure 2e and Figure 3e, respectively, for the three sets. It should be clarified that the value and meaning of m is not comparable between logm_pol and the rest of the codes. Additionally, and for the three matrix sets,

Table 6. Minimum, maximum, mean, and median values for the parameters m and s reached by logm_pol, logm_iss_full, logm_new, and logm for Sets 1–3, respectively.

		m				s
	Min.	Max.	Mean	Median	Min.	Max.	Mean	Median
logm_pol	33+	75+	42.53	42+	3	4	3.89	4
logm_iss_full	7	15	9.36	8	3	5	4.46	5
logm_new	5	7	5.88	6	4	6	5.08	5
logm	5	7	5.88	6	4	6	5.08	5
logm_pol	33+	75+	42.26	45+	3	4	3.92	4
logm_iss_full	7	14	9.23	8	3	5	4.49	5
logm_new	5	7	5.79	6	4	6	5.17	5
logm	5	7	5.79	6	4	6	5.17	5
logm_pol	21+	75+	43.98	39+	0	5	2.83	3
logm_iss_full	6	15	10.15	10	0	36	4.98	4
logm_new	5	7	6.02	6	1	46	6.80	5
logm	5	7	6.02	6	1	46	6.80	5

collects those values of m, together with those ones of s, i.e., the number of matrix square roots computed, in the form of maxima, minima, means, and medians. Whereas the logm_pol function always required values of m much higher than the others, the values of s were more similar among the different codes, always reaching the smallest values on average in the case of logm_pol. Consequently, logm_pol needed to calculate a lower number of square roots compared to those required by the other codes. Moreover, it should be pointed out that logm_iss_full, logm_new, and logm were forced to use an atypically high value of s for a few matrices in Set 3. In all the experiments performed, logm_new and logm always employed an identical value of m and s.

On the other hand, Figure 1f, Figure 2f and Figure 3f and

Table 7. Execution time (T), in seconds, corresponding to logm_pol, logm_iss_full, logm_new, and logm for computing matrices in the three sets.

	T(logm_pol)	T(logm_iss_full)	T(logm_new)	T(logm)
Set 1	16.25	13.11	18.54	4.70
Set 2	15.38	12.34	17.73	4.13
Set 3	5.18	9.01	10.59	1.91

inform us about the execution times spent by the different codes analyzed on computing the logarithm of all the matrices that constituted our testbed. To obtain these overall times, the runs were launched six times, discarding the first one and calculating the average time among the others. As we can appreciate, logm was always the fastest function, followed by logm_iss_full, for Sets 1 and 2, or by logm_pol, for Set 3. In contrast, logm_new always invested the longest time for our three experiments. Numerically speaking, and according to the times recorded for Set 3, logm_pol was 1.74- and 2.04-times faster than logm_iss_full and logm_new, respectively. This notwithstanding, logm_pol and the other codes were clearly outperformed by logm, whose speed of execution in computing the logarithm of this third set of matrices was 2.71-times higher than that of logm_pol.

In more detail, Figure 1g, Figure 2g and Figure 3g provide the ratio between the computation time of the other codes and logm_pol, individually for each of the matrices, in a decreasing order consistent with the factor T(logm_iss_full)/T(logm_pol). As an example, for Set 3, this ratio took values from 0.28 to 15.11 for logm_iss_full, from 0.32 to 28.03 for logm_new, and from 0.05 a 3.93 for logm.

Lastly, it is worth mentioning that, after performing the pertinent execution time profiles, it could be appreciated that much of the time spent by all the codes was involved in the square root computation. Indeed, observe that logm resulted in better execution times than logm_new, despite being two codes that share a similar theoretical scheme. This was mainly due to two reasons: first, because the recursive approach that logm follows to compute the square root of a triangular matrix is much more efficient than that of logm_new; second, this is due to implementation issues since, among others, logm is composed of distinct built-in functions in charge of, for example, calculating the Schur form, solving the Sylvester equation, or solving systems of linear equations, resulting in a very cost-effective code that is not possible to beat in speed as long as all its improvements are not also implemented in its competitors.

4. Conclusions

In this paper, an algorithm to approximate the matrix logarithm was designed. It uses recent matrix polynomial evaluation formulas corresponding to the Taylor series expansion of the logarithm function, which offers a lower computational cost than the Paterson–Stockmeyer method, but similar accuracy. From this algorithm, two MATLAB codes, according to relative forward or backward error analyses, were implemented. They were initially compared with each other and subsequently with MATLAB Codes 4.1 and 5.2 from [32], as well as with the logm built-in MATLAB function. For that, a testbed composed of three distinct types of matrices was used. The numerical results showed that the new Taylor-based codes are usually more accurate than the other state-of-the-art ones, with an intermediate execution time among all of them.