^{1}

^{2}

^{*}

^{1}

^{2}

Edited by: Sorin-Mihai Grad, Technische Universität Chemnitz, Germany

Reviewed by: Vladimir Shikhman, Technische Universität Chemnitz, Germany; Akira Imakura, University of Tsukuba, Japan

This article was submitted to Optimization, a section of the journal Frontiers in Applied Mathematics and Statistics

This is an open-access article distributed under the terms of the Creative Commons Attribution License (CC BY). The use, distribution or reproduction in other forums is permitted, provided the original author(s) and the copyright owner(s) are credited and that the original publication in this journal is cited, in accordance with accepted academic practice. No use, distribution or reproduction is permitted which does not comply with these terms.

Rational filter functions can be used to improve convergence of contour-based eigensolvers, a popular family of algorithms for the solution of the interior eigenvalue problem. We present a framework for the optimization of rational filters based on a non-convex weighted Least-Squares scheme. When used in combination with a contour based eigensolvers library, our filters out-perform existing ones on a large and representative set of benchmark problems. This work provides a detailed description of: (1) a set up of the optimization process that exploits symmetries of the filter function for Hermitian eigenproblems, (2) a formulation of the gradient descent and Levenberg-Marquardt algorithms that exploits the symmetries, (3) a method to select the starting position for the optimization algorithms that reliably produces effective filters, (4) a constrained optimization scheme that produces filter functions with specific properties that may be beneficial to the performance of the eigensolver that employs them.

The last fifteen years have witnessed a proliferation of papers on contour based methods for the solution of the Hermitian interior eigenvalue problem [^{−1} along a contour in the complex plane encircling an interval [

In this paper we conduct a detailed investigation of how a carefully crafted rational function can improve the efficacy of contour based eigensolvers. To this end, we look at the the numerical quadrature of a complex-valued resolvent (^{−1} as an approximation of an ideal filter represented by the standard indicator function. Then, we cast the problem of finding an efficient filter as one of finding a continuous rational function that approximates the discontinuous indicator function so as to improve the effectiveness of the eigensolver. Our method is based on a non-linear Least-Squares optimization process, whose outcome is the simultaneous selection of poles and coefficients characterizing a series of rational filters we termed

Two well-known contour based eigensolvers are the SS family of solvers due to Sakurai and Sugiura [

The correspondence between contour methods and rational filters was discussed for FEAST in Tang and Polizzi [

More recently the filter itself has been treated as a parameter that can be designed via optimization methods. Barel [_{2} norm, not a function approximation approach. Even in the case of Hermitian problems, optimizing the squared distances in only a sample of points must be done with great care. Choosing too small a number of sample points can have undesirable effects: it is possible to obtain poles near the real axis which are not detected by the sample points. On the other hand having a large number of sample points is very expensive. Finally, Barel's approach does not support constraints, as we present in section 4.4.

Xi and Saad present a FEAST related approach for linear Least-Squares optimized filters focusing on the Hermitian eigenproblem [

This manuscript contains the following original contributions:

– Our optimization framework is based on a weighted Least-Squares function computed using the _{2} norm. All the quantities appearing in our optimization are computed using exact formulas for definite integrals as opposed to numerical quadrature. This is a very distinct approach than optimizing the rational function only at a number of sample points via the ℓ_{2} norm as it is done, for instance, in [_{2} integrals. These quantities are then utilized with two distinct optimization methods: the traditional steepest descent and the more effective Levenberg-Marquardt. Flexibility is the landmark of our framework: we present penalty parameters and box constraints to obtain filters that, for example, are better suited for Krylov-based linear system solvers.

– We make explicit the intrinsic symmetries (conjugation and parity) of the rational function approximating the indicator function. As a consequence, when computing the quantities that enter in the optimization process, such as the gradient and Hessian, we keep track of fewer degrees of freedom. Since each process is iterative and the same numerical quantities have to be computed hundreds of thousands of times, reducing the sheer number of them results in at least four times faster numerical executions.

– Optimizing the rational function's poles and coefficients requires the solution of a non-convex problem for which we resort to a non-linear Least-Squares formulation. This is quite a harder problem than optimizing only for the Least-Squares coefficients as it is done, for instance, in [

– We built and implemented an optimization package, written in the Julia language, which is publicly available and easy to use. As it stands the package could be easily integrated in existing eigensolver libraries, such as FEAST, to provide customized rational filters computed on the fly. In order to showcase the promise of our implementation, we also provide ready-to-use SLiSe filters. We compare such filters with existing ones using a large representative problem set. These SLiSe filters can be used as drop-in replacements for the current state-of-the-art spectrum-slicing eigensolver libraries. For instance, in FEAST users can employ the so-called expert routines as described in section 2.2.

The rest of this paper is structured as follows. To showcase the potential of our optimization method, section 2 discusses examples of SLiSe filters. Section 3 considers the formulation of the non-linear Least-Squares problem. We discuss the use of symmetries of the filters, as well as the residual level function and its gradients, which also make use of these symmetries. Section 4 illustrates the full framework for the generation of SLiSe filters with and without constraints. In section 5, we provide additional examples of optimized filters, and we conclude in section 6.

In this section we briefly introduce the basics of subspace iteration with spectral projection. Then we provide an illustration of the effectiveness of our optimization framework by presenting SLiSe filters that are meant as replacements for existing state-of-the-art rational filters. The mathematical setup and methods by which these filters were obtained are the topic of later sections. The filters used in this section, and the optimization parameters used to obtain them, are available in

In section 2.2, we discuss a replacement for the Gauss filter. An improvement for this filter is particularly useful, since the Gauss filter and its variations are the default choice for many contour based solvers [

Given a Hermitian matrix ^{†} ∈ ℂ^{N×N} and a proper interval [_{1}, λ_{N}] ≠ ∅, we are interested in finding the 𝔪 eigenpairs (λ, ^{1}

An efficient subspace iteration method requires a projection procedure that identifies a search subspace approximating the invariant eigenspace corresponding to the eigenvalues lying in the [

where _{i} ∈ ℂ\ℝ and α_{i} ∈ ℂ are all distinct and are chosen in a way such that the eigenvalues of _{[a, b]}(_{i}'s and _{i}'s. Without loss of generality we always consider the search interval to be [−1, 1]. Forming

If we assume that

One of the most well-known solvers for the interior eigenvalue problem based on a rational resolvent followed by the RR projection is the FEAST library [

where Γ is a contour in the complex plane enclosing the search interval [_{i} ∈ ℂ and weights _{i} ∈ ℂ. While any quadrature rule can filter the eigenvalues to some extent, FEAST's defaults to the Gauss-Legendre quadrature rules. From Equation (3) follows that numerical integration of the contour integral is functionally equivalent to the rational filter formulation of Equation (1). Accordingly, we can interpret FEAST's filter function as a rational filter function with _{i} = _{i} and

Plot of the Gauss filter obtained by 16-points Gauss-Legendre quadrature of Equation (3), assuming

Given an ordering of the eigenvalues such that

the convergence ratio of the FEAST algorithm for a chosen filter

For most filters it is the case that

In order to have a fair comparison between an existing filter and our candidate as filter replacement, we need to establish a testing environment. Since our focus is the use of rational filters within subspace iteration methods, we use FEAST as our test environment for comparing filters. A simple filter comparison could use the number of FEAST iterations required to converge the entire subspace for a given matrix

Once the comparison criterion has been selected, a natural way to decide which filter is superior is to select many, representative benchmark problems and see which filter performs better. Comparing filters on only a few, hand-selected, problems can introduce a strong bias. In ^{2}

Comparisons of the Gauss filter with our replacement candidate, γ-SLiSe, with 𝔭 = 1.5𝔪 on a test set of 2116 benchmark problems obtained from the “Si2” matrix. Both filters have 16 poles and are plotted in

The increased performance of the γ-SLiSe filter comes with some drawbacks. On the one hand, the Gauss filter is more versatile than the γ-SLiSe. For instance, outside of the selected interval, the Gauss filter decays very quickly to low values (see

Plots of the Gauss filter and our replacement candidate, γ-SLiSe. Both filters have 16 poles and coefficients.

While

_{f}(_{f}(_{fGauss} (3.4) ≈ 0.88 indicates that for 88% of the benchmark problems the Gauss filter yields a ratio that is at worst a factor of 3.4 from the best. So the performance profiles not only report how often a filter performs best, but also how badly the filter performs when it is not the best. We will use performance profiles multiple times in this section to compare the filters. From the value of ϕ_{fγ-SLiSe}(1) in

A rough insight on the better convergence ratio of the γ-SLiSe filter can be extracted from _{𝔭+1} ≈ ±1.25. Due to a smaller absolute value between 1.1 and 1.6, the γ-SLiSe filter out-performs the state-of-the-art Gauss filter as long as λ_{𝔭+1} ∈ [1.1, 1.6]. If either end of the search interval is near a large spectral cluster then λ_{𝔭+1}≪1.1, and neither of the two filters will do particularly well. In such a case Elliptic filters are used.

The Elliptic filter, also called Cauer or Zolotarev filter, has been proposed for use in the context of the interior eigenvalue problem in a number of publications [^{3}

The Elliptic filter is an optimal filter, in the sense that the filter function is the best uniform rational approximation of the indicator function. For a subspace size of 𝔭 = 𝔪, such a filter is worst-case optimal with respect to the convergence ratio of Equation (4). In simple terms, the Elliptic filter works better than the Gauss filter in the presence of spectral clusters close to the interval boundary because it drops from 1 to 0 more quickly. The η-SLiSe filter trades off slightly larger absolute values inside [1, 1.01] for smaller absolute values in [1.01, ∞] ([−1.01, 1] and [−∞, 1.01], respectively).

_{𝔭+1})| is likely to be close to |_{𝔪})|, so this metric serves as an estimator of the filter's behavior with spectral clusters near the endpoints of the search interval.

Semi-log performance profile of the convergence ratio for the Gauss, η-SLiSe, and Elliptic filters. η-SLiSe is meant to replace the Elliptic filter. All filters have 16 poles and 𝔭 = 𝔪.

The figure indicates that, for our representative set of benchmark problems, the η-SLiSe filter displays better convergence rates than the Elliptic filter. The Elliptic filter achieves the best convergence ratio for half of the benchmark problems, and η-SLiSe does it for the other half. Further, the figure indicates that for 99% of the problems, the Elliptic filter has a convergence ratio at most 2.35 times worse than the best against a factor of 1.38 of the η-SLiSe [ϕ_{fElliptic}(2.35) = 0.99, and ϕ_{fη−SLiSe}(1.38) = 0.99]. Simply put, η-SLiSe performs better than the Elliptic filter for half of the problems, and for the other half it performs very similar to the Elliptical filter. Conversely, the Elliptical filter exhibits convergence rates for some problems that are twice as bad as the convergence rate of η-SLiSe. The Gauss filter exhibits the worst rates of convergence by far, but this is to be expected as the Gauss filter is not meant for this use-case.

Rational filters can be written as a sum of simple rational functions _{i}

with _{i}, α_{i} ∈ ℂ. We restrict ourselves to the case where the _{i} and the α_{i} are pair-wise distinct, and the _{i} have non-zero real and imaginary parts. Our initial goal is to set the stage for the formulation of a reliable method dictating the choice for the poles _{i} and the coefficients α_{i} such that

As _{2} norm which is equivalent to defining a Least-Squares error function, or

An optimal filter, in this sense, is the minimizer of the residual level function

resulting in a weighted Least-Squares optimization problem with the weight function 𝔊(

In section 3.1, we illustrate how to exploit the symmetries of the indicator function

We wish to construct a rational function

Requiring the function _{i}s are conjugate of each other. In other words, half of the poles _{i}s (and corresponding α_{i}s) are in the upper-half of ℂ (indicated as ℍ^{+}) with the other half in the lower-half (ℍ^{−}). Then, without loss of generality we can enumerate the ϕ_{i} such that the first _{i} in ℍ^{+}: _{i} as a sum over half the index range

where we relabeled the poles _{i}s, the coefficients α_{i}s, and the monomials ϕ_{i}s to make the symmetry explicit.

Notice that satisfying the C symmetry forces the association of conjugate coefficients

Imposing the P symmetry explicitly is a bit trickier. It can be visualized as a symmetry for the complex numbers _{j}, β_{j} and their conjugates, living in ℂ. Consider the poles _{k} in the right (R) upper-half of the complex plane ℍ^{+R}, that is those _{k} with ℜ_{k}) > 0 and ℑ_{k}) > 0. Let the number of _{k} in ℍ^{+R} be _{k} with poles _{k} in ℍ^{+R} yields:

Consequently the reflection operation maps a rational monomial with a pole in ℍ^{+R} to a monomial with a pole in ℍ^{−L}. For _{j} monomials with poles in ℍ^{+R} “must” map to the ^{−L}. By complex conjugation, these same _{j} monomials map to ^{−R}, consequently _{j} are in ℍ^{+R}, the second half of ψ_{j} are in the ℍ^{+L}, the first half of ^{−R} and the last ^{−L}. Invariance under reflection implies then that _{k} in ℍ^{+L}. Finally, we can express

Once again, we have relabeled poles, coefficients, and monomials so as to make explicit the symmetry indicated by the

We would have reached the same result if we started to require invariance under the symmetries in reverse order^{4}

Let us expand Equation (7) by temporarily disregarding the discrete symmetries of the rational function and expressing

The residual level function is expressible as

where the

The inner products < ·, ·> are defined through a weight function 𝔊(

and

We could have started directly with the CP invariant formulation from Equation (12) of the rational function _{i}s and α_{i}s were mapped to _{j}s and β_{j}s so as to make explicit the C symmetry. Due to such map, the residual level function has the following block structure:

with

for

and similarly

Now we can require the latter equation to satisfy the reflection symmetry P. Equation (13) maps poles _{j} and coefficients β_{j} respectively to _{k} and γ_{k}, so as to make the reflection symmetry explicit. The residual level function now takes on a new block form

with

for ^{†} =

The direct implication of this observation is that, for instance, ^{π}, ^{π}.

If we expand the matrix expression for the residual level function and exploit all the symmetries the final expression for

Despite the apparent complexity of the expression above, it would have been quite more complex if we started to compute the residual level function directly from Equation (12); the quadratic term in γs alone would have accounted for 16 terms. Moreover the expression is a function of only γ_{k}s and their conjugates.

Most optimization methods—including all the ones that we consider—require the gradient of the residual level function. We could compute the gradients analytically by using the expression for

Since

_{k} and β_{k}

The expression above is the ^{th}-component of the gradients ∇_{v}_{β}

where

After entry-wise substitution of the above components of ∇_{w}_{γ}

The matrices not previously introduced are defined as follows. For

Notice that, in both C-symmetric and CP-symmetric cases, the gradients are row vectors. While this is an arbitrary choice, it is a quite natural one to make. Moreover we decided to maintain the overall multiplicative factor in front of them; such a factor was scaled out of

Our goal is to minimize the residual level function ^{(0)}, ^{(k+1)}) ≤ ^{(k)}). Using the CP symmetries the minimization problem can be stated as

with the initial choice of parameters, or

In section 4.1, we use the the simple gradient-descent method as a first example of minimization of Equation (25). Section 4.2 illustrates the more sophisticated Levenberg-Marquardt method, which is more appropriate for non-convex Least-Squares problems. Depending on the starting position, descent methods, including the Levenberg-Marquardt method, may produce results that are not globally optimal. Section 4.3 deals with the choice of the starting position in a way that mitigates this problem. Section 4.4 delves into constrained optimization where it is advantageous to optimize more than just the squared differences between the filter and the indicator function

In this section we remark, through the most basic descent method—^{(0)} the update step of the gradient descent method is

There are a number of ways to select the

Remark 1 (Slow convergence): Gradient descent is a fairly slow method, with linear convergence behavior at best. Even when equipped with a line-search the number of iterations required to reach a minimum is often in the millions.

In ^{5}

Poles, coefficients, and residual levels of the filter functions show in

_{1} |
+0.997360 + 0.044537 |
+0.721876 + 0.550662 |
+0.742834 + 0.246735 |

_{2} |
+0.721876 + 0.550662 |
+0.997360 + 0.044537 |
+0.744336 + 0.212182 |

γ_{1} |
−0.024019 − 0.002516 |
−0.135117 − 0.148326 |
−0.791429 − 0.331455 |

γ_{2} |
−0.135117 − 0.148326 |
−0.024019 − 0.002516 |
+0.639334 + 0.196414 |

0.005846 | 0.005846 | 0.033640 |

Remark 2 (Dependence on starting position): The filter obtained from the optimization depends on the starting position ^{(0)}. Different starting positions can result in very different filters with different residual levels. Our experiments indicate that when increasing

We address Remark 1 by introducing the Levenberg-Marquardt method [

For the sake of clarity, we re-write the residual level function in terms of ξ ([α

where we indicate the collection of parameters [

which, in the following, we refer to with the shortcut notation ξ + ∇ξ · Δ

Notice that the condition

Using the formulation above, the Gauss-Newton method iterates over

Here

where the gradient of

In practice, the dampening parameter μ is re-adjusted after every iteration. For a small μ, the solution to Equation (28) is similar to the Gauss-Newton update step Δ_{LM} ≃ Δ_{GN}. On the other hand, when μ is large then _{LM} becomes increasingly similar to the gradient descent update.

Since the formulations of the LM method given so far is independent from the symmetry of _{i, j} = 〈∇_{xi}_{xj}

Only two of the matrix blocks composing

where the only additional matrices that need to be defined are

The factor of 2 in front of the block matrices _{1} and _{2} comes from the P symmetry in combination with the evenness of the integral boundaries (i.e. ^{π}, ∇^{π}, etc.). Notice that block rows 3 and 4 of Equation (29) are exactly equivalent, up to a sign, to block rows 2 and 1 respectively. Similarly, block columns 3 and 4 are proportional to block columns 2 and 1. This is expected due to the CP symmetry. In addition, _{1} is complex symmetric (_{2} is complex Hermitian (

Going back to the Equation (28), one can also write the vector Δ_{LM} in block notation,

with (Δ^{⊤} = [Δ^{⊤}Δγ^{⊤}]. Writing Equation (28) in terms of Δ_{1}Δ

The Levemberg-Marquardt method is considerably faster than gradient descent. Let us illustrate their performance difference with a short example. The optimization process for γ-SLiSe carried on with Levemberg-Marquardt (see section 2.2) requires 8.2 · 10^{5} iterations and about 711 s on an Intel i7-5600U CPU. On the other hand, gradient descent needs 1.0 · 10^{7} iterations and about 3.5 h for the same optimization on the same hardware. Comparing the performance of both approaches using only number of iterations can be misleading. Each optimization method performs a very different amount of work per iteration: LM assembles and solves a linear system, while gradient descent performs a line-search and thus evaluates the residual level function many times. Nevetheless, by providing iteration counts and timings there can be no doubt that the LM method is significantly faster than gradient descent. Such result is obtained thanks to the improved convergence of the LM method together with the reduced size of the equation to be solved.

In general, random choices for ^{6}^{−4}, while with ^{−4}. Choosing

We can reinterpret the problem of finding good starting positions for the poles and coefficients as finding a filter that serves as a good initial guess for an optimized filter. To this purpose we could use contour filters expressed through a numerical implementation of Cauchy's Residue Theorem (see section 2.1), namely the Gauss and Trapezoidal filters, or more specialized ones, like the Elliptic filter, that have already been proposed as substitutes for the contour solvers [

Residual levels of Gauss and Elliptic filters, as well as, SLiSe filters obtained from Gauss and Elliptic filters as starting positions.

In this section we discuss two filter properties that can be achieved by implementing constraints on the optimization. First, we introduce a penalty term on the gradient of the filter function, which results in filters of varying “steepness” and with varying amounts of “overshooting.” Given our standard search interval, [−1, 1], we call the derivative of the filter _{t}_{t = 1} = −∇_{t}_{t = −1} the

Note that since ∇_{t}

A different kind of constraint, namely a box constraints on the imaginary part of the poles, may be advantageous when Krylov solvers are used for the linear system solves as they appear in Equation (2). In such cases, the condition number of the shifted matrix _{i}_{i})| is small, which can occur for large degrees of the Elliptic and SLiSe filters. One possible way to circumvent this problem is to ensure that the absolute value of the imaginary part for each pole is large enough. For SLiSe filters this translates into a box constraint

Both approaches to constrained optimization presented in this section require some tuning in the selection of the parameters. This lack of automatism is the exception in our work. Constrained optimization without the need for extensive parameter selection is an area of future work. In section 4.4.1, we discuss how to adjust the optimization to generate filters of varying steepness, while section 4.4.2 describes the box constraints approach.

From a visual inspection of

While it is possible to increase the steepness of SLiSe filters via the penalty term, there is little benefit in even steeper filters with more overshooting. _{t}

Examples of filters obtained via penalty terms.

Residual levels and steepness of the filter functions shown in

0 | 2.265829 × 10^{−5} |
−1.211081 × 10^{4} |

−2 · 10^{−10} |
2.279018 × 10^{−5} |
−1.063877 × 10^{4} |

+2 · 10^{−10} |
2.288353 × 10^{−5} |
−1.429542 × 10^{4} |

Implementing box constraints in our framework is straightforward: Instead of the old update step in Equation (26) we use gradient projection by updating as follows

where _{l} the projection is

In the following, we compare filters with different box constraints. ^{7}

Performance profile comparing the worst condition number for the linear systems arising from filter application to 2116 problems obtained from the “Si2” matrix. The performance ratio for the Elliptic and SLiSe (

_{l} become nearly singular only if _{l} is near an eigenvalue of

The optimization methodology described in section 4 is implemented in a software package written in the Julia programming language and can be accessed by the interested reader in a publicly available repository named SliSeFilters^{8}

Guideline 1 (Outside): Slowly taper off the weights in a large enough neighborhood outside the search interval. In order to avoid trial-and-error, it is advisable to detect increasing local maxima of the absolute value of the rational function during the optimization process and increase the weights where required.

Guideline 2 (Endpoints): The weight function should be selected so as to be symmetric around the endpoints of the search interval. Accordingly, during the optimization process, choose 𝔊(±1 − ϵ) = 𝔊(±1 + ϵ) for ϵ ≤ 0.2. Additionally, if desired, scale the resulting filter to

Guideline 3 (Inside): The weights in the entire search interval should be chosen large enough to prevent large oscillations. During the optimization process, it is advisable to monitor the difference between minima and maxima of the filter inside [−1, 1] and adapt weights accordingly.

In the previous section we discussed a number of techniques to influence the optimization procedure. Some of the filters resulting from this procedure are already presented in section 2. In this section we illustrate the effects of the constrained optimization described in section 4.4 and highlight its potential. First, we discuss η-SLiSe, where a penalty parameter is used to limit overshooting. Second, we present a filter that uses box constraints to achieve better condition numbers for the shifted matrices that arise from the filter application. In these examples the focus is on illustrating the power of the SLiSe filters by showing the improvement over the Elliptic filter. All the experimental tests are executed on the same benchmark set described and used in section 2. For experimental tests using benchmark sets generated from different eigenvalue problems, we refer the reader to the Jupyter notebook which is part of the freely available test suite^{9}

We have seen η-SLiSe in section 2.3, where we compare its convergence rate to the Elliptic and Gauss filters. η-SLiSe was obtained via a negative penalty parameter, to limit the overshooting of the filter. Without the penalty term the filter would perform significantly worse.

Plots of the Elliptic filter, η-SLiSe, and the η-SLiSe filter without penalty term. All filters have 16 poles and coefficients.

The value of the penalty parameter is chosen to be of large absolute value, as compared to the values in section 4.4.1. Such a large penalty parameter results in a significant reduction in the steepness and overshooting of the filter. The difference between the SLiSe filters with and without penalty term is large near the end of the search interval, but negligible in [1.05, ∞]. In “designing” such a filter we first chose the weights such that the filter has the desired behavior for most of the

Semi-log performance profile of the convergence rate for the Gauss, Elliptic, ζ-SLiSe, and κ-SLiSe filters. All filters have 16 poles and 𝔭 = 𝔪. The last two filters violate Guideline 1.

There is another problem with ζ-SLiSe. The filter has a pole with an absolute imaginary value of

To close out this section,

Overview of SLiSe-filters, the section in which each filter is introduced, and a short comment for each filter.

γ-SLiSe | Section 2.2 | Replacement for gauss filter |

ζ-SLiSe | Section 5.1 | Replacement for Elliptic filter; Violation of guideline 1 |

η-SLiSe | Section 2.3 | ζ-SLiSe optimized with use of penalty parameter |

κ-SLiSe | Section 5.2 | ζ-SLiSe optimized with use of box constraints |

In this work we set up a weighted non-linear Least-Squares framework for the optimization of a class of rational filters. Our approach is non-linear in the sense that it optimizes both the pole placement and the coefficients of the rational filters, requiring the solution of a non-convex problem. Because of its non-convexity the iterative optimization process has to be carefully engineered so as to guarantee symmetry preservation and numerical stability. The implementation of such framework in a simple software package offers a rich set of solutions among which we provide with alternatives to the standard Gauss and Elliptic filters that are currently used in contour based eigensolvers.

First, we explicitly formulate the filters to be conjugation and parity invariant. Such a formulation stabilizes the target function and reduces the complexity of the optimization process by at least a factor of four. Because the iterative optimization depends on the initial value of its parameters, convergence to an optimal solution is not easily guaranteed. We show that a careful placement of the starting positions for the poles and the selection of an appropriate optimization algorithm lead to solutions with systematically smaller residuals as the degree of the filter is increased.

When used in combination with a spectrum slicing eigensolver, our optimized rational SLiSe filters can significantly improve the efficiency of contour based eigensolvers on large sets of spectral intervals for any given problem. In the specific instances of the standard Gauss and Elliptic filters, we show-case the flexibility of our approach by providing SLiSe replacements. This flexibility is achieved through the guided selection of Least-Squares weights and the use of constrained optimization. The optimization with box constraints addresses the issue of rational filters with poles very close to the real axis, which lead to almost singular matrix resolvents. Such constrained optimization decreases the condition number of the resolvents, which positively affects the solution of the corresponding linear system solves when Krylov based methods are employed.

Significant effort went into designing the optimization process and its implementation so as to be user-ready. The resulting software is written in the Julia programming language and is available in a public repository together with a test suite and further examples in addition to the one presented in this manuscript. Future work will focus on the automatic selection of the Least-Square weights as well as in more robust optimization approaches when it comes to constraints. The ultimate goal is to provide filters that adapt to any given specific problem. Such filters would be generated on-the-fly and take advantage of spectral information, if cheaply available. Not only do problem-specific filters promise better convergence, but they can provide automatic load balancing between multiple contour “slices.” The present work is meant as a significant step toward such a direction.

All authors listed have made a substantial, direct and intellectual contribution to the work, and approved it for publication.

The authors declare that the research was conducted in the absence of any commercial or financial relationships that could be construed as a potential conflict of interest.

Financial support from the Jülich Aachen Research Alliance High Performance Computing and the Deutsche Forschungsgemeinschaft (DFG) through grant GSC 111 is gratefully acknowledged.

The Supplementary Material for this article can be found online at:

^{1}For notational convenience in the rest of the paper we make use of the ^{†} instead of the conventional ^{H} to indicate Hermitian conjugation.

^{2}Feast was compiled with the Intel Compiler v16.0.2 and executed with a single thread; the target residual was adjusted to 10^{−13}.

^{3}Technically the Elliptic filter is a class of filters depending on a number of parameters. We consider the specific filter discussed in Güttel et al. [

^{4}Physicists refer to the combination of these two discrete symmetries as CP invariance. A necessary condition for its existence is that the operators generating the transformations must commute.

^{5}The Least-Squares weights used to obtain these results are 1.0 inside [−1000, 1000] and 0.0 everywhere else.

^{6}For some spectrum slicing methods, such as the DD-PP projection [

^{7}The weights are available in

^{8}

^{9}