]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Add a script that generates lapack_templates.h.
authorDavid Wells <wellsd2@rpi.edu>
Tue, 29 May 2018 14:39:17 +0000 (10:39 -0400)
committerDavid Wells <wellsd2@rpi.edu>
Wed, 30 May 2018 09:43:16 +0000 (05:43 -0400)
Adding new wrappers to this file is tedious and error-prone. This commit
adds a python script that can generate new bindings automatically from a
list of routines in a text file.

This temporarily disables the complex LAPACK instantiation since those
presently result in compilation errors.

contrib/utilities/generate_lapack_templates [new file with mode: 0755]
contrib/utilities/lapack_templates_data/blas_subroutines [new file with mode: 0644]
contrib/utilities/lapack_templates_data/fp_subroutines [new file with mode: 0644]
contrib/utilities/lapack_templates_data/lapack_subroutines [new file with mode: 0644]
include/deal.II/lac/lapack_templates.h
source/lac/lapack_full_matrix.inst.in

diff --git a/contrib/utilities/generate_lapack_templates b/contrib/utilities/generate_lapack_templates
new file mode 100755 (executable)
index 0000000..5ad6d73
--- /dev/null
@@ -0,0 +1,650 @@
+#!/usr/bin/env python3
+"""This script parses the documentation provided by LAPACK to generate a header
+file declaring prototypes for BLAS and LAPACK functions and definitions of some
+type-generic wrappers (e.g., four overloads for GEMM based on the input types).
+
+To use this file: running
+
+    ./generate_lapack_templates --help
+
+prints descriptions of the different command line arguments. In brief: this file
+reads the three text files in lapack_templates_data/ to determine which wrappers
+it should generate. It generates the wrappers by parsing LAPACK's documentation:
+the location of the library must be provided (with the --lapack-root-directory
+argument).
+
+To add more files: simply put the name of the subroutine (without the type
+prefix, i.e., gemv instead of dgemv) in lapack_templates_data/blas_subroutines
+(for BLAS routines) or lapack_templates_data/lapack_subroutines (for LAPACK
+routines). If any subroutines need to be run with floating point exceptions
+disabled then also add them to lapack_templates_data/fp_exceptions.
+
+"""
+
+import argparse
+import glob
+import os.path as osp
+import re
+import sys
+import time
+
+
+def fortran_to_cpp_type(regex):
+    """Return a C++ type corresponding to the provided regular expression that
+    matches a FORTRAN type.
+    """
+    # TODO surely there is a better way to do this...
+    if isinstance(regex, str):
+        if regex == 'CHARACTER*1':
+            return 'char'
+        if regex == 'CHARACTER':
+            return 'char'
+        if regex == 'INTEGER':
+            return 'dealii::types::blas_int'
+        # TODO the FORTRAN standard states that LOGICAL (default KIND) should have
+        # the same storage size as INTEGER and REAL. Its not clear what happens
+        # when we have 64 bit BLAS and those are no longer equal, so this choice
+        # might not work on big-endian machines.
+        if regex == 'LOGICAL':
+            return 'dealii::types::blas_int'
+        if regex == 'REAL':
+            return 'float'
+        if regex == 'DOUBLE':
+            return 'double'
+        if regex == 'DOUBLE PRECISION':
+            return 'double'
+        if regex == 'COMPLEX':
+            return 'std::complex<float>'
+        if regex == 'COMPLEX*16':
+            return 'std::complex<double>'
+    else:
+        if regex.pattern == 'CHARACTER\\*1':
+            return 'char'
+        if regex.pattern == 'CHARACTER':
+            return 'char'
+        if regex.pattern == 'INTEGER':
+            return 'dealii::types::blas_int'
+        # TODO the FORTRAN standard states that LOGICAL (default KIND) should have
+        # the same storage size as INTEGER and REAL. Its not clear what happens
+        # when we have 64 bit BLAS and those are no longer equal, so this choice
+        # might not work on big-endian machines.
+        if regex.pattern == 'LOGICAL':
+            return 'dealii::types::blas_int'
+        if regex.pattern == 'REAL':
+            return 'float'
+        if regex.pattern == 'DOUBLE (PRECISION)?':
+            return 'double'
+        if regex.pattern == 'COMPLEX[^*]':
+            return 'std::complex<float>'
+        if regex.pattern == 'COMPLEX\\*16':
+            return 'std::complex<double>'
+
+    assert False
+    return None
+
+
+def field_code_to_cpp(string):
+    """Convert a field code (s, d, c, or z) to a C++ type.
+    """
+    if string == 's':
+        return 'float'
+    if string == 'd':
+        return 'double'
+    if string == 'c':
+        return 'std::complex<float>'
+    if string == 'z':
+        return 'std::complex<double>'
+    assert False
+    return None
+
+
+def field_code_to_numeric_ranking(string):
+    """Convert field codes (s, d, c, or z) to a numerical ranking that puts them in
+    that order (rather than alphabetical).
+    """
+    if string == 's':
+        return 0
+    if string == 'd':
+        return 1
+    if string == 'c':
+        return 2
+    if string == 'z':
+        return 3
+    assert False
+    return None
+
+
+def parse_argument_constness(file_name):
+    """Read the given file to determine which arguments are const (i.e.,
+    INTENT(IN)). Since FORTRAN-77 does not support this directly we examine the
+    documentation and consider anything labeled as 'parameter[in]' as const.
+    """
+    store_line = False
+    lines = list()
+    with open(file_name, 'r') as handle:
+        for line in handle:
+            if "Arguments" in line:
+                store_line = True
+            elif "Authors" in line:
+                break
+            if store_line and "param" in line:
+                lines.append(line[3:-1])
+
+    const_parameters = list()
+    for line in lines:
+        # The LAPACK documentation might not be synchronized with the
+        # implementation, but this is the best we can do
+        if "[in]" in line:
+            const_parameters.append(line.split(' ')[-1])
+    return const_parameters
+
+
+def parse_arguments(file_name):
+    """Parse the input arguments to a subroutine by reading its documentation.
+    """
+    store_line = False
+    lines = list()
+    with open(file_name, 'r') as handle:
+        for line in handle:
+            if "Definition" in line:
+                store_line = True
+            elif "Purpose" in line:
+                assert store_line
+                break  # we are done
+
+            if store_line:
+                # remove the prepended '*'
+                lines.append(line[1:].strip())
+
+    # remove lines before 'SUBROUTINE'
+    line = lines[0]
+    while ("SUBROUTINE " not in line and "FUNCTION" not in line):
+        lines.pop(0)
+        line = lines[0]
+
+    # remove blanks and lines with dots
+    lines = list(filter(lambda u: ".." not in u and u != "", lines))
+
+    # get all subroutine arguments in one set of parentheses
+    while ')' not in lines[0]:
+        next_line = lines[1].replace('$', ' ')
+        lines[0] += ' ' + next_line
+        lines.pop(1)
+
+    # join lines that start with '$'s or when the previous line ends in ','
+    line_n = 0
+    while line_n < len(lines):
+        if '$' in lines[line_n]:
+            assert line_n > 0
+            lines[line_n - 1] += ' ' + lines[line_n][1:].strip()
+            lines.pop(line_n)
+        elif line_n > 0 and lines[line_n - 1][-1] == ',':
+            lines[line_n - 1] += ' ' + lines[line_n][1:].strip()
+            lines.pop(line_n)
+        else:
+            line_n += 1
+
+    # since everything is passed by pointer in Fortran, go ahead and delete
+    # array descriptions
+    def remove_text_in_parentheses(string):
+        """Remove all text in parentheses and parentheses themselves.
+        """
+        left_index = string.find('(')
+        if left_index != -1:
+            right_index = string.find(')')
+            assert right_index != -1
+            return remove_text_in_parentheses(string[:left_index]
+                                              + string[right_index + 1:])
+        return string
+
+    return [lines[0]] + list(map(remove_text_in_parentheses, lines[1:]))
+
+
+class FortranRoutine:
+    """Class storing information about a FORTRAN subroutine or function with methods
+    to print it. Has the following members:
+
+    self.file_name : original provided file name
+
+    self.disable_floating_point_exceptions : whether or not to disable floating
+    point exceptions for the duration of the routine call
+
+    self.lines : Lightly edited (preceding '*'s removed, '$' lines joined, etc.)
+    lines from the documentation of the given function that completely describe
+    its function arguments and, if relevant, return type.
+
+    self.const_arguments : List of function arguments that correspond to const
+    pointers: this is derived from 'intent[in]' statements in the FORTRAN
+    function documentation.
+
+    self.return_type : the return type of the subroutine (always void) or
+    function (never void).
+
+    self.field_code : One-letter code ('s', 'd', 'c', or 'z') describing the
+    type of floating point inputs the function expects.
+
+    self.general_name : string containing the general name (i.e., name without
+    field code) of the subroutine or function.
+
+    self.arguments_by_type : A dictionary (with regular expression keys) mapping
+    regular expressions matching FORTRAN types to input arguments.
+    """
+    def __init__(self, file_name, disable_floating_point_exceptions=False):
+        self.file_name = file_name
+        self.disable_floating_point_exceptions = disable_floating_point_exceptions
+        self.lines = parse_arguments(file_name)
+        self.const_arguments = parse_argument_constness(file_name)
+
+        assert "SUBROUTINE" in self.lines[0] or "FUNCTION" in self.lines[0]
+        if "SUBROUTINE" in self.lines[0]:
+            self.return_type = "void"
+            name = self.lines[0].split()[1]
+        else:
+            function_start = self.lines[0].find("FUNCTION")
+            self.return_type = fortran_to_cpp_type(self.lines[0][:function_start].strip())
+            words = self.lines[0].split(' ')
+            while words[0] != "FUNCTION":
+                words.pop(0)
+            name = words[1]
+        parentheses_location = name.find('(')
+        if parentheses_location != -1:
+            name = name[:parentheses_location]
+
+        self.field_code = name[0].lower()
+        self.general_name = name[1:].strip().lower()
+
+        self.arguments_by_type = dict()
+        self.arguments_by_type[re.compile("CHARACTER")] = list()
+        self.arguments_by_type[re.compile("LOGICAL")] = list()
+        self.arguments_by_type[re.compile("INTEGER")] = list()
+        self.arguments_by_type[re.compile("REAL")] = list()
+        self.arguments_by_type[re.compile("DOUBLE (PRECISION)?")] = list()
+        self.arguments_by_type[re.compile("COMPLEX[^*]")] = list()
+        self.arguments_by_type[re.compile("COMPLEX\\*16")] = list()
+        # TODO one day we should support EXTERNAL
+
+        for line in self.lines:
+            found_type = False
+            if line.split() == ["IMPLICIT", "NONE"]:
+                continue
+            if "SUBROUTINE" in line or "FUNCTION" in line:
+                start = line.find('(') + 1
+                end = line.find(')')
+                self.arguments = [u.strip() for u in line[start:end].strip().split(',')]
+                found_type = True
+            else:
+                for key in self.arguments_by_type:
+                    match = key.match(line)
+                    if match is not None:
+                        self.arguments_by_type[key] += [u.strip() for u in
+                                                        line[match.end():].split(',')]
+                        found_type = True
+            if not found_type:
+                if "EXTERNAL" in line:
+                    raise NotImplementedError(
+                        "The parser cannot handle EXTERNAL declarations since "
+                        "FORTRAN does not provide type information in that case.")
+
+            assert found_type
+
+        # for line in self.lines:
+        #     print(line)
+
+        # print("const arguments: ", end='')
+        # print(self.const_arguments)
+        # print(self.general_name)
+        # print(self.arguments)
+        # print([(key, value) for (key, value) in self.arguments_by_type.items()])
+
+    def is_subroutine(self):
+        """Return whether or not the routine is a SUBROUTINE. It might also be a
+        FUNCTION, which is not yet implemented.
+        """
+        for line in self.lines:
+            if "SUBROUTINE" in line:
+                return True
+        return False
+
+    def print_prototype(self, file=sys.stdout):
+        """Print a deal.II-compatible function prototype.
+        """
+        print("", file=file)
+        print("{} {}{}_(".format(self.return_type, self.field_code, self.general_name),
+              end='', file=file)
+        for index, argument in enumerate(self.arguments):
+            found_type = False
+            if argument in self.const_arguments:
+                print("const ", end='', file=file)
+            for (key, arguments) in self.arguments_by_type.items():
+                if argument in arguments:
+                    print(fortran_to_cpp_type(key), end='', file=file)
+                    found_type = True
+
+            if not found_type:
+                import pdb
+                pdb.set_trace()
+            print(" *" + argument.lower(), end='', file=file)
+
+            if index < len(self.arguments) - 1:
+                print(", ", end='', file=file)
+        print(");", file=file)
+
+    def print_base_case_template(self, file=sys.stdout):
+        """Print a deal.II-compatible template base case. Each floating point type is
+        converting to a template parameter. This template will always throw an
+        exception, but is useful as a base case.
+
+        If there are no floating point arguments to the function (e.g., dlamch)
+        then nothing is printed."""
+        excluded_keys = [re.compile("CHARACTER"), re.compile("LOGICAL"),
+                         re.compile("INTEGER")]
+        template_n = 1
+        argument_to_template_type = dict()
+
+        # assign new template types to floating point arguments:
+        for argument in self.arguments:
+            found_type = False
+            for (key, arguments) in self.arguments_by_type.items():
+                if argument in arguments:
+                    if key in excluded_keys:
+                        argument_to_template_type[argument] = fortran_to_cpp_type(key)
+                    else:
+                        argument_to_template_type[argument] = "number" + str(template_n)
+                        template_n += 1
+                    found_type = True
+            assert found_type
+
+        # we number templates from 1, so if we are still at 1 there are no
+        # template arguments. We add one that will also be the return type. To
+        # the best of my knowledge this only happens with DLAMCH and SLAMCH.
+        if template_n == 1:
+            n_template_types = 1
+            assert self.return_type != "void"
+        else:
+            n_template_types = template_n - 1
+
+        print("\n\n", file=file)
+        # print template signature
+        print("template <", end='', file=file)
+        for template_n in range(1, n_template_types + 1):
+            if template_n < n_template_types:
+                print("typename number" + str(template_n) + ", ", end='', file=file)
+            else:
+                print("typename number" + str(template_n) + ">", file=file)
+        print("inline ", file=file)
+        if self.return_type == "void":
+            print(self.return_type, file=file)
+        # since this function will just throw an exception whenever its called
+        # the return type is not important. This also covers the DLAMCH-like
+        # case.
+        else:
+            print("number1", file=file)
+
+        print(self.general_name, file=file)
+        print("(", end='', file=file)
+
+        # print types but not argument names
+        for index, argument in enumerate(self.arguments):
+            if argument in self.const_arguments:
+                print("const ", end='', file=file)
+            print(argument_to_template_type[argument], end='', file=file)
+
+            print(" *", end='', file=file)
+
+            if index < len(self.arguments) - 1:
+                print(", ", end='', file=file)
+
+        print(")", file=file)
+        print("{", file=file)
+        print("  Assert(false, ExcNotImplemented());", file=file)
+        if self.return_type == "void":
+            pass
+        else:
+            print("  return number1();", file=file)
+        print("}", file=file)
+
+    def print_overload_definition(self, file=sys.stdout):
+        """Print a definition of an overload for the present subroutine.
+        """
+        excluded_keys = [re.compile("CHARACTER"), re.compile("LOGICAL"),
+                         re.compile("INTEGER")]
+        # We only specialize the template if there are no function arguments
+        # with which we could deduce the correct function
+        need_template = True
+        for argument in self.arguments:
+            for (key, arguments) in self.arguments_by_type.items():
+                if argument in arguments and key not in excluded_keys:
+                    need_template = False
+                    break
+
+        print("\n\n", file=file)
+        if need_template:
+            print("template <>", file=file)
+        print("inline {}".format(self.return_type), file=file)
+        print(self.general_name, file=file)
+        print("(", end='', file=file)
+
+        # print arguments
+        for index, argument in enumerate(self.arguments):
+            found_type = False
+            if argument in self.const_arguments:
+                print("const ", end='', file=file)
+            for (key, arguments) in self.arguments_by_type.items():
+                if argument in arguments:
+                    print(fortran_to_cpp_type(key), end='', file=file)
+                    found_type = True
+
+            assert found_type
+            print(" *" + argument.lower(), end='', file=file)
+
+            if index < len(self.arguments) - 1:
+                print(", ", end='', file=file)
+        print(")", file=file)
+
+        print("{", file=file)
+        print("#ifdef DEAL_II_WITH_LAPACK", file=file)
+        if self.disable_floating_point_exceptions:
+            print("  // Netlib and Atlas Lapack perform floating point ", end='', file=file)
+            print("tests (e.g. divide-by-zero)", file=file)
+            print("  // within calls to some functions, which cause ", end='', file=file)
+            print("floating point exceptions to be thrown", file=file)
+            print("  // (at least in debug mode). Therefore, we wrap the ", end='', file=file)
+            print("calls into the following ", file=file)
+            print("  // code to suppress the exception.", file=file)
+            print("#ifdef DEAL_II_HAVE_FP_EXCEPTIONS", file=file)
+            print("fenv_t fp_exceptions;", file=file)
+            print("feholdexcept(&fp_exceptions);", file=file)
+            print("#endif // DEAL_II_HAVE_FP_EXCEPTIONS", file=file)
+        # call the Fortran function
+        if self.return_type == "void":
+            print("  ", end='', file=file)
+        else:
+            print("  return ", end='', file=file)
+        print("{}{}_(".format(self.field_code, self.general_name), end='', file=file)
+        for index, argument in enumerate(self.arguments):
+            print(argument.lower(), end='', file=file)
+
+            if index < len(self.arguments) - 1:
+                print(", ", end='', file=file)
+        print(");", file=file)
+
+        if self.disable_floating_point_exceptions:
+            print("#ifdef DEAL_II_HAVE_FP_EXCEPTIONS", file=file)
+            print("fesetenv(&fp_exceptions);", file=file)
+            print("#endif // DEAL_II_HAVE_FP_EXCEPTIONS", file=file)
+
+        print("#else", file=file)
+        for argument in self.arguments:
+            print("  (void){};".format(argument.lower()), file=file)
+        print("  Assert(false, LAPACKSupport::ExcMissing(\"{}\"));"
+              .format(self.field_code + self.general_name), file=file)
+        if self.return_type != "void":
+            print("  return {}();".format(self.return_type), file=file)
+        print("#endif // DEAL_II_WITH_LAPACK", file=file)
+        print("}", file=file)
+
+    def __repr__(self):
+        """Representation of the object.
+        """
+        return self.field_code + self.general_name
+
+
+def main():
+    """Determine the subroutines and then print needed declarations and definitions
+    to the header.
+    """
+    parser = argparse.ArgumentParser()
+    lapack_subroutines = list()
+    blas_subroutines = list()
+    fp_guarded_subroutines = list()
+    parser.add_argument("--lapack-root-directory", type=str,
+                        help="Path of the LAPACK source root directory.")
+    parser.add_argument("--lapack-subroutines", type=str,
+                        help="file listing which LAPACK subroutines we should "
+                        "wrap. Defaults to 'lapack_templates_data/lapack_subroutines' "
+                        "in the current directory.")
+    parser.add_argument("--blas-subroutines", type=str,
+                        help="file listing which BLAS subroutines we should "
+                        "wrap. Defaults to 'lapack_templates_data/blas_subroutines' "
+                        "in the current directory.")
+    parser.add_argument("--fp-guarded-subroutines", type=str,
+                        help="Subroutines which should be wrapped with "
+                        "disabling and enabling of floating point exceptions. "
+                        "Defaults to 'lapack_templates_data/fp_subroutines' in "
+                        "the current directory.")
+    parser.add_argument("--output-file", type=str,
+                        help="File to which we write. Defaults to "
+                        "'lapack_templates.h' in the current directory.")
+    args = vars(parser.parse_args())
+
+    if args["lapack_root_directory"] is None:
+        raise ValueError("The path to the default LAPACK directory must be "
+                         "specified.")
+
+    if args["blas_subroutines"] is None:
+        args["blas_subroutines"] = "lapack_templates_data/blas_subroutines"
+    if args["lapack_subroutines"] is None:
+        args["lapack_subroutines"] = "lapack_templates_data/lapack_subroutines"
+    if args["fp_guarded_subroutines"] is None:
+        args["fp_guarded_subroutines"] = "lapack_templates_data/fp_subroutines"
+    if args["output_file"] is None:
+        args["output_file"] = "lapack_templates.h"
+    print(args)
+
+    with open(args["lapack_subroutines"]) as lapack_handle:
+        for line in lapack_handle:
+            lapack_subroutines.append(line.strip())
+    with open(args["blas_subroutines"]) as blas_handle:
+        for line in blas_handle:
+            blas_subroutines.append(line.strip())
+    with open(args["fp_guarded_subroutines"]) as fp_handle:
+        for line in fp_handle:
+            fp_guarded_subroutines.append(line.strip())
+
+    #
+    # Parse subroutines:
+    #
+    routines = list()
+    all_general_routines = blas_subroutines + lapack_subroutines
+    for [general_routines, routine_directory] in [
+            [lapack_subroutines, args["lapack_root_directory"] + "/SRC/"],
+            # dlamch and slamch are in the INSTALL directory
+            [lapack_subroutines, args["lapack_root_directory"] + "/INSTALL/"],
+            [blas_subroutines, args["lapack_root_directory"] + "/BLAS/SRC/"]]:
+        for general_routine in general_routines:
+            globs = glob.glob(routine_directory + "*" + general_routine + ".f")
+            for file_name in globs:
+                try:
+                    routine_name = osp.basename(file_name)[1:-2]
+                    guard_fp = routine_name in fp_guarded_subroutines
+                    routines.append(FortranRoutine(file_name, guard_fp))
+                except NotImplementedError:
+                    # not a lot we can do. If its in the whitelist we will fail
+                    # again later anway
+                    continue
+            routines.sort(key=lambda u: u.general_name)
+
+    #
+    # Collect subroutines together that have the same general name
+    #
+    organized_routines = list()
+    organized_routines.append([routines[0]])
+    for routine in routines[1:]:
+        if routine.general_name == organized_routines[-1][0].general_name:
+            organized_routines[-1].append(routine)
+        else:
+            organized_routines.append([routine])
+    #
+    # sort by type (s, d, c z)
+    #
+    for routine_list in organized_routines:
+        routine_list.sort(key=lambda a: field_code_to_numeric_ranking(a.field_code))
+
+    #
+    # Generate output
+    #
+    with open(args["output_file"], 'w') as output:
+        print("// ---------------------------------------------------------------------",
+              file=output)
+        print("//",
+              file=output)
+        year = time.ctime().split(' ')[-1]
+        print("// Copyright (C) 2005 - {} by the deal.II authors".format(year),
+              file=output)
+        print("//",
+              file=output)
+        print("// This file is part of the deal.II library.",
+              file=output)
+        print("//",
+              file=output)
+        print("// The deal.II library is free software; you can use it, redistribute",
+              file=output)
+        print("// it, and/or modify it under the terms of the GNU Lesser General",
+              file=output)
+        print("// Public License as published by the Free Software Foundation; either",
+              file=output)
+        print("// version 2.1 of the License, or (at your option) any later version.",
+              file=output)
+        print("// The full text of the license can be found in the file LICENSE at",
+              file=output)
+        print("// the top level of the deal.II distribution.",
+              file=output)
+        print("//",
+              file=output)
+        print("// ---------------------------------------------------------------------",
+              file=output)
+
+        print("", file=output)
+        print("", file=output)
+        print("#ifndef dealii_lapack_templates_h", file=output)
+        print("#define dealii_lapack_templates_h", file=output)
+        print("", file=output)
+        print("#include <deal.II/base/config.h>", file=output)
+        print("", file=output)
+        print("#include <deal.II/lac/lapack_support.h>", file=output)
+        print("", file=output)
+        print("#ifdef DEAL_II_HAVE_FP_EXCEPTIONS", file=output)
+        print("#  include <cfenv>", file=output)
+        print("#endif", file=output)
+
+        print("", file=output)
+        print("extern \"C\"", file=output)
+        print("{", file=output)
+        for routine_list in organized_routines:
+            if routine_list[0].general_name in all_general_routines:
+                for routine in routine_list:
+                    routine.print_prototype(file=output)
+        print("}", file=output)
+
+        print("", file=output)
+        print("DEAL_II_NAMESPACE_OPEN", file=output)
+        print("", file=output)
+        for routine_list in organized_routines:
+            if routine_list[0].general_name in all_general_routines:
+                routine_list[0].print_base_case_template(file=output)
+                for routine in routine_list:
+                    routine.print_overload_definition(file=output)
+
+        print("DEAL_II_NAMESPACE_CLOSE", file=output)
+        print("", file=output)
+        print("#endif", file=output)
diff --git a/contrib/utilities/lapack_templates_data/blas_subroutines b/contrib/utilities/lapack_templates_data/blas_subroutines
new file mode 100644 (file)
index 0000000..e29c900
--- /dev/null
@@ -0,0 +1,6 @@
+axpy
+gemm
+gemv
+trmv
+syr
+syrk
diff --git a/contrib/utilities/lapack_templates_data/fp_subroutines b/contrib/utilities/lapack_templates_data/fp_subroutines
new file mode 100644 (file)
index 0000000..3a506dd
--- /dev/null
@@ -0,0 +1 @@
+syevr
diff --git a/contrib/utilities/lapack_templates_data/lapack_subroutines b/contrib/utilities/lapack_templates_data/lapack_subroutines
new file mode 100644 (file)
index 0000000..38ad89e
--- /dev/null
@@ -0,0 +1,27 @@
+geev
+geevx
+gelsd
+geqrf
+gesdd
+gesvd
+getrf
+getrs
+getri
+lange
+lansy
+lascl
+lamch
+pocon
+potrf
+potri
+potrs
+ormqr
+orgqr
+stev
+syev
+syevr
+syevx
+sygv
+sygvx
+trcon
+trtrs
index 43fc07348709797522cd7cfb93167d5a4a536220..f29205370b73f7989031418890a39e33b3fa9356 100644 (file)
 
 extern "C"
 {
-  // vector update of the form y += alpha*x with a scalar, x,y vectors
   void
-  daxpy_(const dealii::types::blas_int *n,
-         const double *                 alpha,
-         const double *                 x,
+  saxpy_(const dealii::types::blas_int *n,
+         const float *                  sa,
+         const float *                  sx,
          const dealii::types::blas_int *incx,
-         double *                       y,
+         float *                        sy,
          const dealii::types::blas_int *incy);
+
   void
-  saxpy_(const dealii::types::blas_int *n,
-         const float *                  alpha,
-         const float *                  x,
+  daxpy_(const dealii::types::blas_int *n,
+         const double *                 da,
+         const double *                 dx,
          const dealii::types::blas_int *incx,
-         float *                        y,
+         double *                       dy,
          const dealii::types::blas_int *incy);
-  // General Matrix
-  // Matrix vector product
+
   void
-  dgemv_(const char *                   trans,
-         const dealii::types::blas_int *m,
-         const dealii::types::blas_int *n,
-         const double *                 alpha,
-         const double *                 A,
-         const dealii::types::blas_int *lda,
-         const double *                 x,
+  caxpy_(const dealii::types::blas_int *n,
+         const std::complex<float> *    ca,
+         const std::complex<float> *    cx,
          const dealii::types::blas_int *incx,
-         const double *                 b,
-         double *                       y,
+         std::complex<float> *          cy,
          const dealii::types::blas_int *incy);
+
   void
-  sgemv_(const char *                   trans,
-         const dealii::types::blas_int *m,
-         const dealii::types::blas_int *n,
-         const float *                  alpha,
-         const float *                  A,
-         const dealii::types::blas_int *lda,
-         const float *                  x,
+  zaxpy_(const dealii::types::blas_int *n,
+         const std::complex<double> *   za,
+         const std::complex<double> *   zx,
          const dealii::types::blas_int *incx,
-         const float *                  b,
-         float *                        y,
+         std::complex<double> *         zy,
          const dealii::types::blas_int *incy);
+
   void
-  dtrmv_(const char *                   uplo,
-         const char *                   trans,
-         const char *                   diag,
-         const dealii::types::blas_int *N,
-         const double *                 A,
-         const dealii::types::blas_int *lda,
-         double *                       x,
-         const dealii::types::blas_int *incx);
-  void
-  strmv_(const char *                   uplo,
-         const char *                   trans,
-         const char *                   diag,
-         const dealii::types::blas_int *N,
-         const float *                  A,
-         const dealii::types::blas_int *lda,
-         float *                        x,
-         const dealii::types::blas_int *incx);
-  // Matrix matrix product
-  void
-  dgemm_(const char *                   transa,
-         const char *                   transb,
-         const dealii::types::blas_int *m,
+  sgeev_(const char *                   jobvl,
+         const char *                   jobvr,
          const dealii::types::blas_int *n,
-         const dealii::types::blas_int *k,
-         const double *                 alpha,
-         const double *                 A,
+         float *                        a,
          const dealii::types::blas_int *lda,
-         const double *                 B,
-         const dealii::types::blas_int *ldb,
-         const double *                 beta,
-         double *                       C,
-         const dealii::types::blas_int *ldc);
+         float *                        wr,
+         float *                        wi,
+         float *                        vl,
+         const dealii::types::blas_int *ldvl,
+         float *                        vr,
+         const dealii::types::blas_int *ldvr,
+         float *                        work,
+         const dealii::types::blas_int *lwork,
+         dealii::types::blas_int *      info);
+
   void
-  sgemm_(const char *                   transa,
-         const char *                   transb,
-         const dealii::types::blas_int *m,
+  dgeev_(const char *                   jobvl,
+         const char *                   jobvr,
          const dealii::types::blas_int *n,
-         const dealii::types::blas_int *k,
-         const float *                  alpha,
-         const float *                  A,
+         double *                       a,
          const dealii::types::blas_int *lda,
-         const float *                  B,
-         const dealii::types::blas_int *ldb,
-         const float *                  beta,
-         float *                        C,
-         const dealii::types::blas_int *ldc);
-  // Symmetric rank-k update
+         double *                       wr,
+         double *                       wi,
+         double *                       vl,
+         const dealii::types::blas_int *ldvl,
+         double *                       vr,
+         const dealii::types::blas_int *ldvr,
+         double *                       work,
+         const dealii::types::blas_int *lwork,
+         dealii::types::blas_int *      info);
+
   void
-  dsyrk_(const char *                   uplo,
-         const char *                   trans,
+  cgeev_(const char *                   jobvl,
+         const char *                   jobvr,
          const dealii::types::blas_int *n,
-         const dealii::types::blas_int *k,
-         const double *                 alpha,
-         const double *                 A,
+         std::complex<float> *          a,
          const dealii::types::blas_int *lda,
-         const double *                 beta,
-         double *                       C,
-         const dealii::types::blas_int *ldc);
+         std::complex<float> *          w,
+         std::complex<float> *          vl,
+         const dealii::types::blas_int *ldvl,
+         std::complex<float> *          vr,
+         const dealii::types::blas_int *ldvr,
+         std::complex<float> *          work,
+         const dealii::types::blas_int *lwork,
+         float *                        rwork,
+         dealii::types::blas_int *      info);
+
   void
-  ssyrk_(const char *                   uplo,
-         const char *                   trans,
+  zgeev_(const char *                   jobvl,
+         const char *                   jobvr,
          const dealii::types::blas_int *n,
-         const dealii::types::blas_int *k,
-         const float *                  alpha,
-         const float *                  A,
+         std::complex<double> *         a,
          const dealii::types::blas_int *lda,
-         const float *                  beta,
-         float *                        C,
-         const dealii::types::blas_int *ldc);
-  // Compute LU factorization
-  void
-  dgetrf_(const dealii::types::blas_int *m,
-          const dealii::types::blas_int *n,
-          double *                       A,
-          const dealii::types::blas_int *lda,
-          dealii::types::blas_int *      ipiv,
-          dealii::types::blas_int *      info);
-  void
-  sgetrf_(const dealii::types::blas_int *m,
-          const dealii::types::blas_int *n,
-          float *                        A,
-          const dealii::types::blas_int *lda,
-          dealii::types::blas_int *      ipiv,
-          dealii::types::blas_int *      info);
-  // Apply forward/backward substitution to LU factorization
-  void
-  dgetrs_(const char *                   trans,
-          const dealii::types::blas_int *n,
-          const dealii::types::blas_int *nrhs,
-          const double *                 A,
-          const dealii::types::blas_int *lda,
-          const dealii::types::blas_int *ipiv,
-          double *                       b,
-          const dealii::types::blas_int *ldb,
-          dealii::types::blas_int *      info);
+         std::complex<double> *         w,
+         std::complex<double> *         vl,
+         const dealii::types::blas_int *ldvl,
+         std::complex<double> *         vr,
+         const dealii::types::blas_int *ldvr,
+         std::complex<double> *         work,
+         const dealii::types::blas_int *lwork,
+         double *                       rwork,
+         dealii::types::blas_int *      info);
+
   void
-  sgetrs_(const char *                   trans,
+  sgeevx_(const char *                   balanc,
+          const char *                   jobvl,
+          const char *                   jobvr,
+          const char *                   sense,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *nrhs,
-          const float *                  A,
-          const dealii::types::blas_int *lda,
-          const dealii::types::blas_int *ipiv,
-          float *                        b,
-          const dealii::types::blas_int *ldb,
-          dealii::types::blas_int *      info);
-  // Invert matrix from LU factorization
-  void
-  dgetri_(const dealii::types::blas_int *n,
-          double *                       A,
+          float *                        a,
           const dealii::types::blas_int *lda,
-          dealii::types::blas_int *      ipiv,
-          double *                       inv_work,
+          float *                        wr,
+          float *                        wi,
+          float *                        vl,
+          const dealii::types::blas_int *ldvl,
+          float *                        vr,
+          const dealii::types::blas_int *ldvr,
+          dealii::types::blas_int *      ilo,
+          dealii::types::blas_int *      ihi,
+          float *                        scale,
+          float *                        abnrm,
+          float *                        rconde,
+          float *                        rcondv,
+          float *                        work,
           const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
+
   void
-  sgetri_(const dealii::types::blas_int *n,
-          float *                        A,
+  dgeevx_(const char *                   balanc,
+          const char *                   jobvl,
+          const char *                   jobvr,
+          const char *                   sense,
+          const dealii::types::blas_int *n,
+          double *                       a,
           const dealii::types::blas_int *lda,
-          dealii::types::blas_int *      ipiv,
-          float *                        inv_work,
+          double *                       wr,
+          double *                       wi,
+          double *                       vl,
+          const dealii::types::blas_int *ldvl,
+          double *                       vr,
+          const dealii::types::blas_int *ldvr,
+          dealii::types::blas_int *      ilo,
+          dealii::types::blas_int *      ihi,
+          double *                       scale,
+          double *                       abnrm,
+          double *                       rconde,
+          double *                       rcondv,
+          double *                       work,
           const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
-  // Compute Cholesky factorization of SPD
+
   void
-  dpotrf_(const char *                   uplo,
+  cgeevx_(const char *                   balanc,
+          const char *                   jobvl,
+          const char *                   jobvr,
+          const char *                   sense,
           const dealii::types::blas_int *n,
-          double *                       A,
+          std::complex<float> *          a,
           const dealii::types::blas_int *lda,
+          std::complex<float> *          w,
+          std::complex<float> *          vl,
+          const dealii::types::blas_int *ldvl,
+          std::complex<float> *          vr,
+          const dealii::types::blas_int *ldvr,
+          dealii::types::blas_int *      ilo,
+          dealii::types::blas_int *      ihi,
+          float *                        scale,
+          float *                        abnrm,
+          float *                        rconde,
+          float *                        rcondv,
+          std::complex<float> *          work,
+          const dealii::types::blas_int *lwork,
+          float *                        rwork,
           dealii::types::blas_int *      info);
+
   void
-  spotrf_(const char *                   uplo,
+  zgeevx_(const char *                   balanc,
+          const char *                   jobvl,
+          const char *                   jobvr,
+          const char *                   sense,
           const dealii::types::blas_int *n,
-          float *                        A,
+          std::complex<double> *         a,
           const dealii::types::blas_int *lda,
+          std::complex<double> *         w,
+          std::complex<double> *         vl,
+          const dealii::types::blas_int *ldvl,
+          std::complex<double> *         vr,
+          const dealii::types::blas_int *ldvr,
+          dealii::types::blas_int *      ilo,
+          dealii::types::blas_int *      ihi,
+          double *                       scale,
+          double *                       abnrm,
+          double *                       rconde,
+          double *                       rcondv,
+          std::complex<double> *         work,
+          const dealii::types::blas_int *lwork,
+          double *                       rwork,
           dealii::types::blas_int *      info);
-  // Apply forward/backward substitution to Cholesky factorization
+
   void
-  dpotrs_(const char *                   uplo,
+  sgelsd_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
           const dealii::types::blas_int *nrhs,
-          const double *                 A,
+          float *                        a,
           const dealii::types::blas_int *lda,
-          double *                       B,
+          float *                        b,
           const dealii::types::blas_int *ldb,
+          float *                        s,
+          const float *                  rcond,
+          dealii::types::blas_int *      rank,
+          float *                        work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
+
   void
-  spotrs_(const char *                   uplo,
+  dgelsd_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
           const dealii::types::blas_int *nrhs,
-          const float *                  A,
+          double *                       a,
           const dealii::types::blas_int *lda,
-          float *                        B,
+          double *                       b,
           const dealii::types::blas_int *ldb,
-          dealii::types::blas_int *      info);
-  // Estimate the reciprocal of the condition number in 1-norm from Cholesky
-  void
-  dpocon_(const char *                   uplo,
-          const dealii::types::blas_int *n,
-          const double *                 A,
-          const dealii::types::blas_int *lda,
-          const double *                 anorm,
-          double *                       rcond,
+          double *                       s,
+          const double *                 rcond,
+          dealii::types::blas_int *      rank,
           double *                       work,
+          const dealii::types::blas_int *lwork,
           dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
+
   void
-  spocon_(const char *                   uplo,
-          const dealii::types::blas_int *n,
-          const float *                  A,
-          const dealii::types::blas_int *lda,
-          const float *                  anorm,
-          float *                        rcond,
-          float *                        work,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      info);
-  // Estimate the reciprocal of the condition number of triangular matrices
-  // http://www.netlib.org/lapack/explore-html/da/dba/group__double_o_t_h_e_rcomputational_gaff914510b1673e90752c095f5b9dcedf.html#gaff914510b1673e90752c095f5b9dcedf
-  void
-  dtrcon_(const char *                   norm,
-          const char *                   uplo,
-          const char *                   diag,
+  cgelsd_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const double *                 A,
+          const dealii::types::blas_int *nrhs,
+          std::complex<float> *          a,
           const dealii::types::blas_int *lda,
-          double *                       rcond,
-          double *                       work,
+          std::complex<float> *          b,
+          const dealii::types::blas_int *ldb,
+          float *                        s,
+          const float *                  rcond,
+          dealii::types::blas_int *      rank,
+          std::complex<float> *          work,
+          const dealii::types::blas_int *lwork,
+          float *                        rwork,
           dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
+
   void
-  strcon_(const char *                   norm,
-          const char *                   uplo,
-          const char *                   diag,
+  zgelsd_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const float *                  A,
+          const dealii::types::blas_int *nrhs,
+          std::complex<double> *         a,
           const dealii::types::blas_int *lda,
-          float *                        rcond,
-          float *                        work,
+          std::complex<double> *         b,
+          const dealii::types::blas_int *ldb,
+          double *                       s,
+          const double *                 rcond,
+          dealii::types::blas_int *      rank,
+          std::complex<double> *         work,
+          const dealii::types::blas_int *lwork,
+          double *                       rwork,
           dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
-  // Computes the inverse from Cholesky
+
   void
-  dpotri_(const char *                   uplo,
-          const dealii::types::blas_int *n,
-          double *                       A,
-          const dealii::types::blas_int *lda,
-          dealii::types::blas_int *      info);
+  sgemm_(const char *                   transa,
+         const char *                   transb,
+         const dealii::types::blas_int *m,
+         const dealii::types::blas_int *n,
+         const dealii::types::blas_int *k,
+         const float *                  alpha,
+         const float *                  a,
+         const dealii::types::blas_int *lda,
+         const float *                  b,
+         const dealii::types::blas_int *ldb,
+         const float *                  beta,
+         float *                        c,
+         const dealii::types::blas_int *ldc);
+
   void
-  spotri_(const char *                   uplo,
+  dgemm_(const char *                   transa,
+         const char *                   transb,
+         const dealii::types::blas_int *m,
+         const dealii::types::blas_int *n,
+         const dealii::types::blas_int *k,
+         const double *                 alpha,
+         const double *                 a,
+         const dealii::types::blas_int *lda,
+         const double *                 b,
+         const dealii::types::blas_int *ldb,
+         const double *                 beta,
+         double *                       c,
+         const dealii::types::blas_int *ldc);
+
+  void
+  cgemm_(const char *                   transa,
+         const char *                   transb,
+         const dealii::types::blas_int *m,
+         const dealii::types::blas_int *n,
+         const dealii::types::blas_int *k,
+         const std::complex<float> *    alpha,
+         const std::complex<float> *    a,
+         const dealii::types::blas_int *lda,
+         const std::complex<float> *    b,
+         const dealii::types::blas_int *ldb,
+         const std::complex<float> *    beta,
+         std::complex<float> *          c,
+         const dealii::types::blas_int *ldc);
+
+  void
+  zgemm_(const char *                   transa,
+         const char *                   transb,
+         const dealii::types::blas_int *m,
+         const dealii::types::blas_int *n,
+         const dealii::types::blas_int *k,
+         const std::complex<double> *   alpha,
+         const std::complex<double> *   a,
+         const dealii::types::blas_int *lda,
+         const std::complex<double> *   b,
+         const dealii::types::blas_int *ldb,
+         const std::complex<double> *   beta,
+         std::complex<double> *         c,
+         const dealii::types::blas_int *ldc);
+
+  void
+  sgemv_(const char *                   trans,
+         const dealii::types::blas_int *m,
+         const dealii::types::blas_int *n,
+         const float *                  alpha,
+         const float *                  a,
+         const dealii::types::blas_int *lda,
+         const float *                  x,
+         const dealii::types::blas_int *incx,
+         const float *                  beta,
+         float *                        y,
+         const dealii::types::blas_int *incy);
+
+  void
+  dgemv_(const char *                   trans,
+         const dealii::types::blas_int *m,
+         const dealii::types::blas_int *n,
+         const double *                 alpha,
+         const double *                 a,
+         const dealii::types::blas_int *lda,
+         const double *                 x,
+         const dealii::types::blas_int *incx,
+         const double *                 beta,
+         double *                       y,
+         const dealii::types::blas_int *incy);
+
+  void
+  cgemv_(const char *                   trans,
+         const dealii::types::blas_int *m,
+         const dealii::types::blas_int *n,
+         const std::complex<float> *    alpha,
+         const std::complex<float> *    a,
+         const dealii::types::blas_int *lda,
+         const std::complex<float> *    x,
+         const dealii::types::blas_int *incx,
+         const std::complex<float> *    beta,
+         std::complex<float> *          y,
+         const dealii::types::blas_int *incy);
+
+  void
+  zgemv_(const char *                   trans,
+         const dealii::types::blas_int *m,
+         const dealii::types::blas_int *n,
+         const std::complex<double> *   alpha,
+         const std::complex<double> *   a,
+         const dealii::types::blas_int *lda,
+         const std::complex<double> *   x,
+         const dealii::types::blas_int *incx,
+         const std::complex<double> *   beta,
+         std::complex<double> *         y,
+         const dealii::types::blas_int *incy);
+
+  void
+  sgeqrf_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          float *                        A,
+          float *                        a,
           const dealii::types::blas_int *lda,
+          float *                        tau,
+          float *                        work,
+          const dealii::types::blas_int *lwork,
           dealii::types::blas_int *      info);
-  // Norms
-  double
-  dlansy_(const char *                   norm,
-          const char *                   uplo,
+
+  void
+  dgeqrf_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const double *                 A,
+          double *                       a,
           const dealii::types::blas_int *lda,
-          double *                       work);
-  float
-  slansy_(const char *                   norm,
-          const char *                   uplo,
+          double *                       tau,
+          double *                       work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      info);
+
+  void
+  cgeqrf_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const float *                  A,
+          std::complex<float> *          a,
           const dealii::types::blas_int *lda,
-          float *                        work);
-  double
-  dlange_(const char *                   norm,
-          const dealii::types::blas_int *m,
+          std::complex<float> *          tau,
+          std::complex<float> *          work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      info);
+
+  void
+  zgeqrf_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const double *                 A,
+          std::complex<double> *         a,
           const dealii::types::blas_int *lda,
-          double *                       work);
-  float
-  slange_(const char *                   norm,
+          std::complex<double> *         tau,
+          std::complex<double> *         work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      info);
+
+  void
+  sgesdd_(const char *                   jobz,
           const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const float *                  A,
+          float *                        a,
           const dealii::types::blas_int *lda,
-          float *                        work);
+          float *                        s,
+          float *                        u,
+          const dealii::types::blas_int *ldu,
+          float *                        vt,
+          const dealii::types::blas_int *ldvt,
+          float *                        work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      info);
 
-  // Compute QR factorization (Householder)
   void
-  dgeqrf_(const dealii::types::blas_int *m,
+  dgesdd_(const char *                   jobz,
+          const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          double *                       A,
+          double *                       a,
           const dealii::types::blas_int *lda,
-          double *                       tau,
+          double *                       s,
+          double *                       u,
+          const dealii::types::blas_int *ldu,
+          double *                       vt,
+          const dealii::types::blas_int *ldvt,
           double *                       work,
           const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
+
   void
-  sgeqrf_(const dealii::types::blas_int *m,
+  cgesdd_(const char *                   jobz,
+          const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          float *                        A,
+          std::complex<float> *          a,
           const dealii::types::blas_int *lda,
-          float *                        tau,
-          float *                        work,
+          float *                        s,
+          std::complex<float> *          u,
+          const dealii::types::blas_int *ldu,
+          std::complex<float> *          vt,
+          const dealii::types::blas_int *ldvt,
+          std::complex<float> *          work,
           const dealii::types::blas_int *lwork,
+          float *                        rwork,
+          dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
-  // Compute vector Q^T B, where Q is the result from dgeqrf_
+
   void
-  dormqr_(const char *                   side,
-          const char *                   trans,
+  zgesdd_(const char *                   jobz,
           const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *k,
-          const double *                 A,
+          std::complex<double> *         a,
           const dealii::types::blas_int *lda,
-          const double *                 tau,
-          double *                       B,
-          const dealii::types::blas_int *ldb,
-          double *                       work,
+          double *                       s,
+          std::complex<double> *         u,
+          const dealii::types::blas_int *ldu,
+          std::complex<double> *         vt,
+          const dealii::types::blas_int *ldvt,
+          std::complex<double> *         work,
           const dealii::types::blas_int *lwork,
+          double *                       rwork,
+          dealii::types::blas_int *      iwork,
           dealii::types::blas_int *      info);
+
   void
-  sormqr_(const char *                   side,
-          const char *                   trans,
+  sgesvd_(const char *                   jobu,
+          const char *                   jobvt,
           const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *k,
-          const float *                  A,
+          float *                        a,
           const dealii::types::blas_int *lda,
-          const float *                  tau,
-          float *                        B,
-          const dealii::types::blas_int *ldb,
+          float *                        s,
+          float *                        u,
+          const dealii::types::blas_int *ldu,
+          float *                        vt,
+          const dealii::types::blas_int *ldvt,
           float *                        work,
           const dealii::types::blas_int *lwork,
           dealii::types::blas_int *      info);
-  // Compute matrix Q from the result of dgeqrf_
+
   void
-  dorgqr_(const dealii::types::blas_int *m,
+  dgesvd_(const char *                   jobu,
+          const char *                   jobvt,
+          const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *k,
-          const double *                 A,
+          double *                       a,
           const dealii::types::blas_int *lda,
-          const double *                 tau,
+          double *                       s,
+          double *                       u,
+          const dealii::types::blas_int *ldu,
+          double *                       vt,
+          const dealii::types::blas_int *ldvt,
           double *                       work,
           const dealii::types::blas_int *lwork,
           dealii::types::blas_int *      info);
+
   void
-  sorgqr_(const dealii::types::blas_int *m,
+  cgesvd_(const char *                   jobu,
+          const char *                   jobvt,
+          const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *k,
-          const float *                  A,
+          std::complex<float> *          a,
           const dealii::types::blas_int *lda,
-          const float *                  tau,
-          float *                        work,
+          float *                        s,
+          std::complex<float> *          u,
+          const dealii::types::blas_int *ldu,
+          std::complex<float> *          vt,
+          const dealii::types::blas_int *ldvt,
+          std::complex<float> *          work,
           const dealii::types::blas_int *lwork,
+          float *                        rwork,
           dealii::types::blas_int *      info);
-  // Compute Rx = b
+
   void
-  dtrtrs_(const char *                   uplo,
-          const char *                   trans,
-          const char *                   diag,
+  zgesvd_(const char *                   jobu,
+          const char *                   jobvt,
+          const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *n_rhs,
-          const double *                 A,
+          std::complex<double> *         a,
           const dealii::types::blas_int *lda,
-          double *                       B,
-          const dealii::types::blas_int *ldb,
+          double *                       s,
+          std::complex<double> *         u,
+          const dealii::types::blas_int *ldu,
+          std::complex<double> *         vt,
+          const dealii::types::blas_int *ldvt,
+          std::complex<double> *         work,
+          const dealii::types::blas_int *lwork,
+          double *                       rwork,
           dealii::types::blas_int *      info);
+
   void
-  strtrs_(const char *                   uplo,
-          const char *                   trans,
-          const char *                   diag,
+  sgetrf_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *n_rhs,
-          const float *                  A,
+          float *                        a,
           const dealii::types::blas_int *lda,
-          float *                        B,
-          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      ipiv,
           dealii::types::blas_int *      info);
-  // Compute eigenvalues and vectors
-  void
-  dgeev_(const char *                   jobvl,
-         const char *                   jobvr,
-         const dealii::types::blas_int *n,
-         double *                       A,
-         const dealii::types::blas_int *lda,
-         double *                       lambda_re,
-         double *                       lambda_im,
-         double *                       vl,
-         const dealii::types::blas_int *ldvl,
-         double *                       vr,
-         const dealii::types::blas_int *ldva,
-         double *                       work,
-         const dealii::types::blas_int *lwork,
-         dealii::types::blas_int *      info);
-  void
-  sgeev_(const char *                   jobvl,
-         const char *                   jobvr,
-         const dealii::types::blas_int *n,
-         float *                        A,
-         const dealii::types::blas_int *lda,
-         float *                        lambda_re,
-         float *                        lambda_im,
-         float *                        vl,
-         const dealii::types::blas_int *ldvl,
-         float *                        vr,
-         const dealii::types::blas_int *ldva,
-         float *                        work,
-         const dealii::types::blas_int *lwork,
-         dealii::types::blas_int *      info);
-  // Compute eigenvalues and vectors (expert)
+
   void
-  dgeevx_(const char *                   balanc,
-          const char *                   jobvl,
-          const char *                   jobvr,
-          const char *                   sense,
+  dgetrf_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          double *                       A,
+          double *                       a,
           const dealii::types::blas_int *lda,
-          double *                       lambda_re,
-          double *                       lambda_im,
-          double *                       vl,
-          const dealii::types::blas_int *ldvl,
-          double *                       vr,
-          const dealii::types::blas_int *ldvr,
-          dealii::types::blas_int *      ilo,
-          dealii::types::blas_int *      ihi,
-          double *                       scale,
-          double *                       abnrm,
-          double *                       rconde,
-          double *                       rcondv,
-          double *                       work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      ipiv,
           dealii::types::blas_int *      info);
+
   void
-  sgeevx_(const char *                   balanc,
-          const char *                   jobvl,
-          const char *                   jobvr,
-          const char *                   sense,
+  cgetrf_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          float *                        A,
+          std::complex<float> *          a,
           const dealii::types::blas_int *lda,
-          float *                        lambda_re,
-          float *                        lambda_im,
-          float *                        vl,
-          const dealii::types::blas_int *ldvl,
-          float *                        vr,
-          const dealii::types::blas_int *ldvr,
-          dealii::types::blas_int *      ilo,
-          dealii::types::blas_int *      ihi,
-          float *                        scale,
-          float *                        abnrm,
-          float *                        rconde,
-          float *                        rcondv,
-          float *                        work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      ipiv,
           dealii::types::blas_int *      info);
-  // Eigenvalues for a symmetric matrix
-  void
-  dsyev_(const char *                   jobz,
-         const char *                   uplo,
-         const dealii::types::blas_int *n,
-         double *                       A,
-         const dealii::types::blas_int *lda,
-         double *                       w,
-         double *                       work,
-         const dealii::types::blas_int *lwork,
-         dealii::types::blas_int *      info);
-  void
-  ssyev_(const char *                   jobz,
-         const char *                   uplo,
-         const dealii::types::blas_int *n,
-         float *                        A,
-         const dealii::types::blas_int *lda,
-         float *                        w,
-         float *                        work,
-         const dealii::types::blas_int *lwork,
-         dealii::types::blas_int *      info);
-  // Same functionality as dsyev_ but with more options: E.g.
-  // Compute only eigenvalues in a specific dealii::types::blas_interval,
-  // Compute only eigenvalues with a specific index,
-  // Set tolerance for eigenvalue computation
+
   void
-  dsyevx_(const char *                   jobz,
-          const char *                   range,
-          const char *                   uplo,
+  zgetrf_(const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          double *                       A,
+          std::complex<double> *         a,
           const dealii::types::blas_int *lda,
-          const double *                 vl,
-          const double *                 vu,
-          const dealii::types::blas_int *il,
-          const dealii::types::blas_int *iu,
-          const double *                 abstol,
-          dealii::types::blas_int *      m,
-          double *                       w,
-          double *                       z,
-          const dealii::types::blas_int *ldz,
-          double *                       work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      ifail,
+          dealii::types::blas_int *      ipiv,
           dealii::types::blas_int *      info);
+
   void
-  ssyevx_(const char *                   jobz,
-          const char *                   range,
-          const char *                   uplo,
-          const dealii::types::blas_int *n,
-          float *                        A,
+  sgetri_(const dealii::types::blas_int *n,
+          float *                        a,
           const dealii::types::blas_int *lda,
-          const float *                  vl,
-          const float *                  vu,
-          const dealii::types::blas_int *il,
-          const dealii::types::blas_int *iu,
-          const float *                  abstol,
-          dealii::types::blas_int *      m,
-          float *                        w,
-          float *                        z,
-          const dealii::types::blas_int *ldz,
+          const dealii::types::blas_int *ipiv,
           float *                        work,
           const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      ifail,
           dealii::types::blas_int *      info);
-  // Same functionality as dsyev_ but using MRRR algorithm and with more
-  // options: E.g. compute only eigenvalues in a specific
-  // dealii::types::blas_interval, Compute only eigenvalues with a specific
-  // index.
+
   void
-  dsyevr_(const char *                   jobz,
-          const char *                   range,
-          const char *                   uplo,
-          const dealii::types::blas_int *n,
-          double *                       A,
+  dgetri_(const dealii::types::blas_int *n,
+          double *                       a,
           const dealii::types::blas_int *lda,
-          const double *                 vl,
-          const double *                 vu,
-          const dealii::types::blas_int *il,
-          const dealii::types::blas_int *iu,
-          const double *                 abstol,
-          dealii::types::blas_int *      m,
-          double *                       w,
-          double *                       z,
-          const dealii::types::blas_int *ldz,
-          dealii::types::blas_int *      isuppz,
+          const dealii::types::blas_int *ipiv,
           double *                       work,
-          dealii::types::blas_int *      lwork,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      liwork,
+          const dealii::types::blas_int *lwork,
           dealii::types::blas_int *      info);
+
   void
-  ssyevr_(const char *                   jobz,
-          const char *                   range,
-          const char *                   uplo,
-          const dealii::types::blas_int *n,
-          float *                        A,
+  cgetri_(const dealii::types::blas_int *n,
+          std::complex<float> *          a,
           const dealii::types::blas_int *lda,
-          const float *                  vl,
-          const float *                  vu,
-          const dealii::types::blas_int *il,
-          const dealii::types::blas_int *iu,
-          const float *                  abstol,
-          dealii::types::blas_int *      m,
-          float *                        w,
-          float *                        z,
-          const dealii::types::blas_int *ldz,
-          dealii::types::blas_int *      isuppz,
-          float *                        work,
-          dealii::types::blas_int *      lwork,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      liwork,
+          const dealii::types::blas_int *ipiv,
+          std::complex<float> *          work,
+          const dealii::types::blas_int *lwork,
           dealii::types::blas_int *      info);
-  // Generalized eigenvalues and eigenvectors of
-  // 1: A*x = lambda*B*x; 2: A*B*x = lambda*x; 3: B*A*x = lambda*x
-  // A and B are symmetric and B is definite
-  void
-  dsygv_(const dealii::types::blas_int *itype,
-         const char *                   jobz,
-         const char *                   uplo,
-         const dealii::types::blas_int *n,
-         double *                       A,
-         const dealii::types::blas_int *lda,
-         double *                       B,
-         const dealii::types::blas_int *ldb,
-         double *                       w,
-         double *                       work,
-         const dealii::types::blas_int *lwork,
-         dealii::types::blas_int *      info);
-  void
-  ssygv_(const dealii::types::blas_int *itype,
-         const char *                   jobz,
-         const char *                   uplo,
-         const dealii::types::blas_int *n,
-         float *                        A,
-         const dealii::types::blas_int *lda,
-         float *                        B,
-         const dealii::types::blas_int *ldb,
-         float *                        w,
-         float *                        work,
-         const dealii::types::blas_int *lwork,
-         dealii::types::blas_int *      info);
-  // Same functionality as dsygv_ but with more options: E.g.
-  // Compute only eigenvalues in a specific dealii::types::blas_interval,
-  // Compute only eigenvalues with a specific index,
-  // Set tolerance for eigenvalue computation
+
   void
-  dsygvx_(const dealii::types::blas_int *itype,
-          const char *                   jobz,
-          const char *                   range,
-          const char *                   uplo,
-          const dealii::types::blas_int *n,
-          double *                       A,
+  zgetri_(const dealii::types::blas_int *n,
+          std::complex<double> *         a,
           const dealii::types::blas_int *lda,
-          double *                       B,
-          const dealii::types::blas_int *ldb,
-          const double *                 vl,
-          const double *                 vu,
-          const dealii::types::blas_int *il,
-          const dealii::types::blas_int *iu,
-          const double *                 abstol,
-          dealii::types::blas_int *      m,
-          double *                       w,
-          double *                       z,
-          const dealii::types::blas_int *ldz,
-          double *                       work,
+          const dealii::types::blas_int *ipiv,
+          std::complex<double> *         work,
           const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      ifail,
           dealii::types::blas_int *      info);
+
   void
-  ssygvx_(const dealii::types::blas_int *itype,
-          const char *                   jobz,
-          const char *                   range,
-          const char *                   uplo,
+  sgetrs_(const char *                   trans,
           const dealii::types::blas_int *n,
-          float *                        A,
+          const dealii::types::blas_int *nrhs,
+          const float *                  a,
           const dealii::types::blas_int *lda,
-          float *                        B,
+          const dealii::types::blas_int *ipiv,
+          float *                        b,
           const dealii::types::blas_int *ldb,
-          const float *                  vl,
-          const float *                  vu,
-          const dealii::types::blas_int *il,
-          const dealii::types::blas_int *iu,
-          const float *                  abstol,
-          dealii::types::blas_int *      m,
-          float *                        w,
-          float *                        z,
-          const dealii::types::blas_int *ldz,
-          float *                        work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      ifail,
           dealii::types::blas_int *      info);
-  // Compute singular value decomposition using divide and conquer
+
   void
-  dgesdd_(const char *                   jobz,
-          const dealii::types::blas_int *m,
+  dgetrs_(const char *                   trans,
           const dealii::types::blas_int *n,
-          double *                       A,
+          const dealii::types::blas_int *nrhs,
+          const double *                 a,
           const dealii::types::blas_int *lda,
-          double *                       s,
-          double *                       u,
-          const dealii::types::blas_int *ldu,
-          double *                       vt,
-          const dealii::types::blas_int *ldvt,
-          double *                       work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
+          const dealii::types::blas_int *ipiv,
+          double *                       b,
+          const dealii::types::blas_int *ldb,
           dealii::types::blas_int *      info);
+
   void
-  sgesdd_(const char *                   jobz,
-          const dealii::types::blas_int *m,
+  cgetrs_(const char *                   trans,
           const dealii::types::blas_int *n,
-          float *                        A,
+          const dealii::types::blas_int *nrhs,
+          const std::complex<float> *    a,
           const dealii::types::blas_int *lda,
-          float *                        s,
-          float *                        u,
-          const dealii::types::blas_int *ldu,
-          float *                        vt,
-          const dealii::types::blas_int *ldvt,
-          float *                        work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
+          const dealii::types::blas_int *ipiv,
+          std::complex<float> *          b,
+          const dealii::types::blas_int *ldb,
           dealii::types::blas_int *      info);
-  // Compute singular value decomposition
+
   void
-  dgesvd_(dealii::types::blas_int *      jobu,
-          dealii::types::blas_int *      jobvt,
+  zgetrs_(const char *                   trans,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *m,
-          double *                       A,
+          const dealii::types::blas_int *nrhs,
+          const std::complex<double> *   a,
           const dealii::types::blas_int *lda,
-          double *                       s,
-          double *                       u,
-          const dealii::types::blas_int *ldu,
-          double *                       vt,
-          const dealii::types::blas_int *ldvt,
-          double *                       work,
-          const dealii::types::blas_int *lwork,
+          const dealii::types::blas_int *ipiv,
+          std::complex<double> *         b,
+          const dealii::types::blas_int *ldb,
           dealii::types::blas_int *      info);
-  void
-  sgesvd_(dealii::types::blas_int *      jobu,
-          dealii::types::blas_int *      jobvt,
+
+  float
+  slamch_(const char *cmach);
+
+  double
+  dlamch_(const char *cmach);
+
+  float
+  slange_(const char *                   norm,
+          const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
+          const float *                  a,
+          const dealii::types::blas_int *lda,
+          float *                        work);
+
+  double
+  dlange_(const char *                   norm,
           const dealii::types::blas_int *m,
-          float *                        A,
+          const dealii::types::blas_int *n,
+          const double *                 a,
           const dealii::types::blas_int *lda,
-          float *                        s,
-          float *                        u,
-          const dealii::types::blas_int *ldu,
-          float *                        vt,
-          const dealii::types::blas_int *ldvt,
-          float *                        work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      info);
-  // Solve a least squares problem using SVD
-  void
-  dgelsd_(const dealii::types::blas_int *m,
+          double *                       work);
+
+  float
+  clange_(const char *                   norm,
+          const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *nrhs,
-          const double *                 A,
+          const std::complex<float> *    a,
           const dealii::types::blas_int *lda,
-          double *                       B,
-          const dealii::types::blas_int *ldb,
-          double *                       s,
-          const double *                 rcond,
-          dealii::types::blas_int *      rank,
-          double *                       work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      info);
-  void
-  sgelsd_(const dealii::types::blas_int *m,
+          float *                        work);
+
+  double
+  zlange_(const char *                   norm,
+          const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          const dealii::types::blas_int *nrhs,
-          const float *                  A,
+          const std::complex<double> *   a,
           const dealii::types::blas_int *lda,
-          float *                        B,
-          const dealii::types::blas_int *ldb,
-          float *                        s,
-          const float *                  rcond,
-          dealii::types::blas_int *      rank,
-          float *                        work,
-          const dealii::types::blas_int *lwork,
-          dealii::types::blas_int *      iwork,
-          dealii::types::blas_int *      info);
-  // Symmetric tridiagonal matrix
-  void
-  dstev_(const char *                   jobz,
-         const dealii::types::blas_int *n,
-         double *                       d,
-         double *                       e,
-         double *                       z,
-         const dealii::types::blas_int *ldz,
-         double *                       work,
-         dealii::types::blas_int *      info);
-  void
-  sstev_(const char *                   jobz,
-         const dealii::types::blas_int *n,
-         float *                        d,
-         float *                        e,
-         float *                        z,
-         const dealii::types::blas_int *ldz,
-         float *                        work,
-         dealii::types::blas_int *      info);
-  // Rank-1 update for symmetric matrices
-  void
-  dsyr_(const char *                   uplo,
-        const dealii::types::blas_int *n,
-        const double *                 alpha,
-        const double *                 x,
-        const dealii::types::blas_int *incx,
-        double *                       A,
-        const dealii::types::blas_int *lda);
+          double *                       work);
+
+  float
+  slansy_(const char *                   norm,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const float *                  a,
+          const dealii::types::blas_int *lda,
+          float *                        work);
+
+  double
+  dlansy_(const char *                   norm,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const double *                 a,
+          const dealii::types::blas_int *lda,
+          double *                       work);
+
+  float
+  clansy_(const char *                   norm,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const std::complex<float> *    a,
+          const dealii::types::blas_int *lda,
+          float *                        work);
+
+  double
+  zlansy_(const char *                   norm,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const std::complex<double> *   a,
+          const dealii::types::blas_int *lda,
+          double *                       work);
+
   void
-  ssyr_(const char *                   uplo,
-        const dealii::types::blas_int *n,
-        const float *                  alpha,
-        const float *                  x,
-        const dealii::types::blas_int *incx,
-        float *                        A,
-        const dealii::types::blas_int *lda);
-  // Multiply rectangular mxn real matrix by real scalar CTO/CFROM
+  slascl_(const char *                   type,
+          const dealii::types::blas_int *kl,
+          const dealii::types::blas_int *ku,
+          const float *                  cfrom,
+          const float *                  cto,
+          const dealii::types::blas_int *m,
+          const dealii::types::blas_int *n,
+          float *                        a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
   void
   dlascl_(const char *                   type,
           const dealii::types::blas_int *kl,
@@ -817,1863 +773,3861 @@ extern "C"
           const double *                 cto,
           const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          double *                       A,
+          double *                       a,
           const dealii::types::blas_int *lda,
           dealii::types::blas_int *      info);
+
   void
-  slascl_(const char *                   type,
+  clascl_(const char *                   type,
           const dealii::types::blas_int *kl,
           const dealii::types::blas_int *ku,
           const float *                  cfrom,
           const float *                  cto,
           const dealii::types::blas_int *m,
           const dealii::types::blas_int *n,
-          float *                        A,
+          std::complex<float> *          a,
           const dealii::types::blas_int *lda,
           dealii::types::blas_int *      info);
-  // dlamch and slamch help determining machine precision
-  double
-  dlamch_(const char *chmach);
-  float
-  slamch_(const char *chmach);
+
+  void
+  zlascl_(const char *                   type,
+          const dealii::types::blas_int *kl,
+          const dealii::types::blas_int *ku,
+          const double *                 cfrom,
+          const double *                 cto,
+          const dealii::types::blas_int *m,
+          const dealii::types::blas_int *n,
+          std::complex<double> *         a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  sorgqr_(const dealii::types::blas_int *m,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *k,
+          float *                        a,
+          const dealii::types::blas_int *lda,
+          const float *                  tau,
+          float *                        work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      info);
+
+  void
+  dorgqr_(const dealii::types::blas_int *m,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *k,
+          double *                       a,
+          const dealii::types::blas_int *lda,
+          const double *                 tau,
+          double *                       work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      info);
+
+  void
+  sormqr_(const char *                   side,
+          const char *                   trans,
+          const dealii::types::blas_int *m,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *k,
+          const float *                  a,
+          const dealii::types::blas_int *lda,
+          const float *                  tau,
+          float *                        c,
+          const dealii::types::blas_int *ldc,
+          float *                        work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      info);
+
+  void
+  dormqr_(const char *                   side,
+          const char *                   trans,
+          const dealii::types::blas_int *m,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *k,
+          const double *                 a,
+          const dealii::types::blas_int *lda,
+          const double *                 tau,
+          double *                       c,
+          const dealii::types::blas_int *ldc,
+          double *                       work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      info);
+
+  void
+  spocon_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const float *                  a,
+          const dealii::types::blas_int *lda,
+          const float *                  anorm,
+          float *                        rcond,
+          float *                        work,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      info);
+
+  void
+  dpocon_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const double *                 a,
+          const dealii::types::blas_int *lda,
+          const double *                 anorm,
+          double *                       rcond,
+          double *                       work,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      info);
+
+  void
+  cpocon_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const std::complex<float> *    a,
+          const dealii::types::blas_int *lda,
+          const float *                  anorm,
+          float *                        rcond,
+          std::complex<float> *          work,
+          float *                        rwork,
+          dealii::types::blas_int *      info);
+
+  void
+  zpocon_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const std::complex<double> *   a,
+          const dealii::types::blas_int *lda,
+          const double *                 anorm,
+          double *                       rcond,
+          std::complex<double> *         work,
+          double *                       rwork,
+          dealii::types::blas_int *      info);
+
+  void
+  spotrf_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          float *                        a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  dpotrf_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          double *                       a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  cpotrf_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          std::complex<float> *          a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  zpotrf_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          std::complex<double> *         a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  spotri_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          float *                        a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  dpotri_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          double *                       a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  cpotri_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          std::complex<float> *          a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  zpotri_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          std::complex<double> *         a,
+          const dealii::types::blas_int *lda,
+          dealii::types::blas_int *      info);
+
+  void
+  spotrs_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *nrhs,
+          const float *                  a,
+          const dealii::types::blas_int *lda,
+          float *                        b,
+          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      info);
+
+  void
+  dpotrs_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *nrhs,
+          const double *                 a,
+          const dealii::types::blas_int *lda,
+          double *                       b,
+          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      info);
+
+  void
+  cpotrs_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *nrhs,
+          const std::complex<float> *    a,
+          const dealii::types::blas_int *lda,
+          std::complex<float> *          b,
+          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      info);
+
+  void
+  zpotrs_(const char *                   uplo,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *nrhs,
+          const std::complex<double> *   a,
+          const dealii::types::blas_int *lda,
+          std::complex<double> *         b,
+          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      info);
+
+  void
+  sstev_(const char *                   jobz,
+         const dealii::types::blas_int *n,
+         float *                        d,
+         float *                        e,
+         float *                        z,
+         const dealii::types::blas_int *ldz,
+         float *                        work,
+         dealii::types::blas_int *      info);
+
+  void
+  dstev_(const char *                   jobz,
+         const dealii::types::blas_int *n,
+         double *                       d,
+         double *                       e,
+         double *                       z,
+         const dealii::types::blas_int *ldz,
+         double *                       work,
+         dealii::types::blas_int *      info);
+
+  void
+  ssyev_(const char *                   jobz,
+         const char *                   uplo,
+         const dealii::types::blas_int *n,
+         float *                        a,
+         const dealii::types::blas_int *lda,
+         float *                        w,
+         float *                        work,
+         const dealii::types::blas_int *lwork,
+         dealii::types::blas_int *      info);
+
+  void
+  dsyev_(const char *                   jobz,
+         const char *                   uplo,
+         const dealii::types::blas_int *n,
+         double *                       a,
+         const dealii::types::blas_int *lda,
+         double *                       w,
+         double *                       work,
+         const dealii::types::blas_int *lwork,
+         dealii::types::blas_int *      info);
+
+  void
+  ssyevr_(const char *                   jobz,
+          const char *                   range,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          float *                        a,
+          const dealii::types::blas_int *lda,
+          const float *                  vl,
+          const float *                  vu,
+          const dealii::types::blas_int *il,
+          const dealii::types::blas_int *iu,
+          const float *                  abstol,
+          dealii::types::blas_int *      m,
+          float *                        w,
+          float *                        z,
+          const dealii::types::blas_int *ldz,
+          dealii::types::blas_int *      isuppz,
+          float *                        work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
+          const dealii::types::blas_int *liwork,
+          dealii::types::blas_int *      info);
+
+  void
+  dsyevr_(const char *                   jobz,
+          const char *                   range,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          double *                       a,
+          const dealii::types::blas_int *lda,
+          const double *                 vl,
+          const double *                 vu,
+          const dealii::types::blas_int *il,
+          const dealii::types::blas_int *iu,
+          const double *                 abstol,
+          dealii::types::blas_int *      m,
+          double *                       w,
+          double *                       z,
+          const dealii::types::blas_int *ldz,
+          dealii::types::blas_int *      isuppz,
+          double *                       work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
+          const dealii::types::blas_int *liwork,
+          dealii::types::blas_int *      info);
+
+  void
+  ssyevx_(const char *                   jobz,
+          const char *                   range,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          float *                        a,
+          const dealii::types::blas_int *lda,
+          const float *                  vl,
+          const float *                  vu,
+          const dealii::types::blas_int *il,
+          const dealii::types::blas_int *iu,
+          const float *                  abstol,
+          dealii::types::blas_int *      m,
+          float *                        w,
+          float *                        z,
+          const dealii::types::blas_int *ldz,
+          float *                        work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      ifail,
+          dealii::types::blas_int *      info);
+
+  void
+  dsyevx_(const char *                   jobz,
+          const char *                   range,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          double *                       a,
+          const dealii::types::blas_int *lda,
+          const double *                 vl,
+          const double *                 vu,
+          const dealii::types::blas_int *il,
+          const dealii::types::blas_int *iu,
+          const double *                 abstol,
+          dealii::types::blas_int *      m,
+          double *                       w,
+          double *                       z,
+          const dealii::types::blas_int *ldz,
+          double *                       work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      ifail,
+          dealii::types::blas_int *      info);
+
+  void
+  ssygv_(const dealii::types::blas_int *itype,
+         const char *                   jobz,
+         const char *                   uplo,
+         const dealii::types::blas_int *n,
+         float *                        a,
+         const dealii::types::blas_int *lda,
+         float *                        b,
+         const dealii::types::blas_int *ldb,
+         float *                        w,
+         float *                        work,
+         const dealii::types::blas_int *lwork,
+         dealii::types::blas_int *      info);
+
+  void
+  dsygv_(const dealii::types::blas_int *itype,
+         const char *                   jobz,
+         const char *                   uplo,
+         const dealii::types::blas_int *n,
+         double *                       a,
+         const dealii::types::blas_int *lda,
+         double *                       b,
+         const dealii::types::blas_int *ldb,
+         double *                       w,
+         double *                       work,
+         const dealii::types::blas_int *lwork,
+         dealii::types::blas_int *      info);
+
+  void
+  ssygvx_(const dealii::types::blas_int *itype,
+          const char *                   jobz,
+          const char *                   range,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          float *                        a,
+          const dealii::types::blas_int *lda,
+          float *                        b,
+          const dealii::types::blas_int *ldb,
+          const float *                  vl,
+          const float *                  vu,
+          const dealii::types::blas_int *il,
+          const dealii::types::blas_int *iu,
+          const float *                  abstol,
+          dealii::types::blas_int *      m,
+          float *                        w,
+          float *                        z,
+          const dealii::types::blas_int *ldz,
+          float *                        work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      ifail,
+          dealii::types::blas_int *      info);
+
+  void
+  dsygvx_(const dealii::types::blas_int *itype,
+          const char *                   jobz,
+          const char *                   range,
+          const char *                   uplo,
+          const dealii::types::blas_int *n,
+          double *                       a,
+          const dealii::types::blas_int *lda,
+          double *                       b,
+          const dealii::types::blas_int *ldb,
+          const double *                 vl,
+          const double *                 vu,
+          const dealii::types::blas_int *il,
+          const dealii::types::blas_int *iu,
+          const double *                 abstol,
+          dealii::types::blas_int *      m,
+          double *                       w,
+          double *                       z,
+          const dealii::types::blas_int *ldz,
+          double *                       work,
+          const dealii::types::blas_int *lwork,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      ifail,
+          dealii::types::blas_int *      info);
+
+  void
+  ssyr_(const char *                   uplo,
+        const dealii::types::blas_int *n,
+        const float *                  alpha,
+        const float *                  x,
+        const dealii::types::blas_int *incx,
+        float *                        a,
+        const dealii::types::blas_int *lda);
+
+  void
+  dsyr_(const char *                   uplo,
+        const dealii::types::blas_int *n,
+        const double *                 alpha,
+        const double *                 x,
+        const dealii::types::blas_int *incx,
+        double *                       a,
+        const dealii::types::blas_int *lda);
+
+  void
+  ssyrk_(const char *                   uplo,
+         const char *                   trans,
+         const dealii::types::blas_int *n,
+         const dealii::types::blas_int *k,
+         const float *                  alpha,
+         const float *                  a,
+         const dealii::types::blas_int *lda,
+         const float *                  beta,
+         float *                        c,
+         const dealii::types::blas_int *ldc);
+
+  void
+  dsyrk_(const char *                   uplo,
+         const char *                   trans,
+         const dealii::types::blas_int *n,
+         const dealii::types::blas_int *k,
+         const double *                 alpha,
+         const double *                 a,
+         const dealii::types::blas_int *lda,
+         const double *                 beta,
+         double *                       c,
+         const dealii::types::blas_int *ldc);
+
+  void
+  csyrk_(const char *                   uplo,
+         const char *                   trans,
+         const dealii::types::blas_int *n,
+         const dealii::types::blas_int *k,
+         const std::complex<float> *    alpha,
+         const std::complex<float> *    a,
+         const dealii::types::blas_int *lda,
+         const std::complex<float> *    beta,
+         std::complex<float> *          c,
+         const dealii::types::blas_int *ldc);
+
+  void
+  zsyrk_(const char *                   uplo,
+         const char *                   trans,
+         const dealii::types::blas_int *n,
+         const dealii::types::blas_int *k,
+         const std::complex<double> *   alpha,
+         const std::complex<double> *   a,
+         const dealii::types::blas_int *lda,
+         const std::complex<double> *   beta,
+         std::complex<double> *         c,
+         const dealii::types::blas_int *ldc);
+
+  void
+  strcon_(const char *                   norm,
+          const char *                   uplo,
+          const char *                   diag,
+          const dealii::types::blas_int *n,
+          const float *                  a,
+          const dealii::types::blas_int *lda,
+          float *                        rcond,
+          float *                        work,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      info);
+
+  void
+  dtrcon_(const char *                   norm,
+          const char *                   uplo,
+          const char *                   diag,
+          const dealii::types::blas_int *n,
+          const double *                 a,
+          const dealii::types::blas_int *lda,
+          double *                       rcond,
+          double *                       work,
+          dealii::types::blas_int *      iwork,
+          dealii::types::blas_int *      info);
+
+  void
+  ctrcon_(const char *                   norm,
+          const char *                   uplo,
+          const char *                   diag,
+          const dealii::types::blas_int *n,
+          const std::complex<float> *    a,
+          const dealii::types::blas_int *lda,
+          float *                        rcond,
+          std::complex<float> *          work,
+          float *                        rwork,
+          dealii::types::blas_int *      info);
+
+  void
+  ztrcon_(const char *                   norm,
+          const char *                   uplo,
+          const char *                   diag,
+          const dealii::types::blas_int *n,
+          const std::complex<double> *   a,
+          const dealii::types::blas_int *lda,
+          double *                       rcond,
+          std::complex<double> *         work,
+          double *                       rwork,
+          dealii::types::blas_int *      info);
+
+  void
+  strmv_(const char *                   uplo,
+         const char *                   trans,
+         const char *                   diag,
+         const dealii::types::blas_int *n,
+         const float *                  a,
+         const dealii::types::blas_int *lda,
+         float *                        x,
+         const dealii::types::blas_int *incx);
+
+  void
+  dtrmv_(const char *                   uplo,
+         const char *                   trans,
+         const char *                   diag,
+         const dealii::types::blas_int *n,
+         const double *                 a,
+         const dealii::types::blas_int *lda,
+         double *                       x,
+         const dealii::types::blas_int *incx);
+
+  void
+  ctrmv_(const char *                   uplo,
+         const char *                   trans,
+         const char *                   diag,
+         const dealii::types::blas_int *n,
+         const std::complex<float> *    a,
+         const dealii::types::blas_int *lda,
+         std::complex<float> *          x,
+         const dealii::types::blas_int *incx);
+
+  void
+  ztrmv_(const char *                   uplo,
+         const char *                   trans,
+         const char *                   diag,
+         const dealii::types::blas_int *n,
+         const std::complex<double> *   a,
+         const dealii::types::blas_int *lda,
+         std::complex<double> *         x,
+         const dealii::types::blas_int *incx);
+
+  void
+  strtrs_(const char *                   uplo,
+          const char *                   trans,
+          const char *                   diag,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *nrhs,
+          const float *                  a,
+          const dealii::types::blas_int *lda,
+          float *                        b,
+          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      info);
+
+  void
+  dtrtrs_(const char *                   uplo,
+          const char *                   trans,
+          const char *                   diag,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *nrhs,
+          const double *                 a,
+          const dealii::types::blas_int *lda,
+          double *                       b,
+          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      info);
+
+  void
+  ctrtrs_(const char *                   uplo,
+          const char *                   trans,
+          const char *                   diag,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *nrhs,
+          const std::complex<float> *    a,
+          const dealii::types::blas_int *lda,
+          std::complex<float> *          b,
+          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      info);
+
+  void
+  ztrtrs_(const char *                   uplo,
+          const char *                   trans,
+          const char *                   diag,
+          const dealii::types::blas_int *n,
+          const dealii::types::blas_int *nrhs,
+          const std::complex<double> *   a,
+          const dealii::types::blas_int *lda,
+          std::complex<double> *         b,
+          const dealii::types::blas_int *ldb,
+          dealii::types::blas_int *      info);
+}
+
+DEAL_II_NAMESPACE_OPEN
+
+
+
+template <typename number1, typename number2, typename number3>
+inline void
+axpy(const dealii::types::blas_int *,
+     const number1 *,
+     const number2 *,
+     const dealii::types::blas_int *,
+     number3 *,
+     const dealii::types::blas_int *)
+{
+  Assert(false, ExcNotImplemented());
+}
+
+
+
+inline void
+axpy(const dealii::types::blas_int *n,
+     const float *                  sa,
+     const float *                  sx,
+     const dealii::types::blas_int *incx,
+     float *                        sy,
+     const dealii::types::blas_int *incy)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  saxpy_(n, sa, sx, incx, sy, incy);
+#else
+  (void)n;
+  (void)sa;
+  (void)sx;
+  (void)incx;
+  (void)sy;
+  (void)incy;
+  Assert(false, LAPACKSupport::ExcMissing("saxpy"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+axpy(const dealii::types::blas_int *n,
+     const double *                 da,
+     const double *                 dx,
+     const dealii::types::blas_int *incx,
+     double *                       dy,
+     const dealii::types::blas_int *incy)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  daxpy_(n, da, dx, incx, dy, incy);
+#else
+  (void)n;
+  (void)da;
+  (void)dx;
+  (void)incx;
+  (void)dy;
+  (void)incy;
+  Assert(false, LAPACKSupport::ExcMissing("daxpy"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+axpy(const dealii::types::blas_int *n,
+     const std::complex<float> *    ca,
+     const std::complex<float> *    cx,
+     const dealii::types::blas_int *incx,
+     std::complex<float> *          cy,
+     const dealii::types::blas_int *incy)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  caxpy_(n, ca, cx, incx, cy, incy);
+#else
+  (void)n;
+  (void)ca;
+  (void)cx;
+  (void)incx;
+  (void)cy;
+  (void)incy;
+  Assert(false, LAPACKSupport::ExcMissing("caxpy"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+axpy(const dealii::types::blas_int *n,
+     const std::complex<double> *   za,
+     const std::complex<double> *   zx,
+     const dealii::types::blas_int *incx,
+     std::complex<double> *         zy,
+     const dealii::types::blas_int *incy)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  zaxpy_(n, za, zx, incx, zy, incy);
+#else
+  (void)n;
+  (void)za;
+  (void)zx;
+  (void)incx;
+  (void)zy;
+  (void)incy;
+  Assert(false, LAPACKSupport::ExcMissing("zaxpy"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4,
+          typename number5,
+          typename number6>
+inline void
+geev(const char *,
+     const char *,
+     const dealii::types::blas_int *,
+     number1 *,
+     const dealii::types::blas_int *,
+     number2 *,
+     number3 *,
+     number4 *,
+     const dealii::types::blas_int *,
+     number5 *,
+     const dealii::types::blas_int *,
+     number6 *,
+     const dealii::types::blas_int *,
+     dealii::types::blas_int *)
+{
+  Assert(false, ExcNotImplemented());
+}
+
+
+
+inline void
+geev(const char *                   jobvl,
+     const char *                   jobvr,
+     const dealii::types::blas_int *n,
+     float *                        a,
+     const dealii::types::blas_int *lda,
+     float *                        wr,
+     float *                        wi,
+     float *                        vl,
+     const dealii::types::blas_int *ldvl,
+     float *                        vr,
+     const dealii::types::blas_int *ldvr,
+     float *                        work,
+     const dealii::types::blas_int *lwork,
+     dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgeev_(
+    jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info);
+#else
+  (void)jobvl;
+  (void)jobvr;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)wr;
+  (void)wi;
+  (void)vl;
+  (void)ldvl;
+  (void)vr;
+  (void)ldvr;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgeev"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+geev(const char *                   jobvl,
+     const char *                   jobvr,
+     const dealii::types::blas_int *n,
+     double *                       a,
+     const dealii::types::blas_int *lda,
+     double *                       wr,
+     double *                       wi,
+     double *                       vl,
+     const dealii::types::blas_int *ldvl,
+     double *                       vr,
+     const dealii::types::blas_int *ldvr,
+     double *                       work,
+     const dealii::types::blas_int *lwork,
+     dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  dgeev_(
+    jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info);
+#else
+  (void)jobvl;
+  (void)jobvr;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)wr;
+  (void)wi;
+  (void)vl;
+  (void)ldvl;
+  (void)vr;
+  (void)ldvr;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgeev"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+geev(const char *                   jobvl,
+     const char *                   jobvr,
+     const dealii::types::blas_int *n,
+     std::complex<float> *          a,
+     const dealii::types::blas_int *lda,
+     std::complex<float> *          w,
+     std::complex<float> *          vl,
+     const dealii::types::blas_int *ldvl,
+     std::complex<float> *          vr,
+     const dealii::types::blas_int *ldvr,
+     std::complex<float> *          work,
+     const dealii::types::blas_int *lwork,
+     float *                        rwork,
+     dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  cgeev_(
+    jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info);
+#else
+  (void)jobvl;
+  (void)jobvr;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)w;
+  (void)vl;
+  (void)ldvl;
+  (void)vr;
+  (void)ldvr;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgeev"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+geev(const char *                   jobvl,
+     const char *                   jobvr,
+     const dealii::types::blas_int *n,
+     std::complex<double> *         a,
+     const dealii::types::blas_int *lda,
+     std::complex<double> *         w,
+     std::complex<double> *         vl,
+     const dealii::types::blas_int *ldvl,
+     std::complex<double> *         vr,
+     const dealii::types::blas_int *ldvr,
+     std::complex<double> *         work,
+     const dealii::types::blas_int *lwork,
+     double *                       rwork,
+     dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  zgeev_(
+    jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info);
+#else
+  (void)jobvl;
+  (void)jobvr;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)w;
+  (void)vl;
+  (void)ldvl;
+  (void)vr;
+  (void)ldvr;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgeev"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4,
+          typename number5,
+          typename number6,
+          typename number7,
+          typename number8,
+          typename number9,
+          typename number10>
+inline void
+geevx(const char *,
+      const char *,
+      const char *,
+      const char *,
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      number2 *,
+      number3 *,
+      number4 *,
+      const dealii::types::blas_int *,
+      number5 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      number6 *,
+      number7 *,
+      number8 *,
+      number9 *,
+      number10 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *)
+{
+  Assert(false, ExcNotImplemented());
+}
+
+
+
+inline void
+geevx(const char *                   balanc,
+      const char *                   jobvl,
+      const char *                   jobvr,
+      const char *                   sense,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      float *                        wr,
+      float *                        wi,
+      float *                        vl,
+      const dealii::types::blas_int *ldvl,
+      float *                        vr,
+      const dealii::types::blas_int *ldvr,
+      dealii::types::blas_int *      ilo,
+      dealii::types::blas_int *      ihi,
+      float *                        scale,
+      float *                        abnrm,
+      float *                        rconde,
+      float *                        rcondv,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgeevx_(balanc,
+          jobvl,
+          jobvr,
+          sense,
+          n,
+          a,
+          lda,
+          wr,
+          wi,
+          vl,
+          ldvl,
+          vr,
+          ldvr,
+          ilo,
+          ihi,
+          scale,
+          abnrm,
+          rconde,
+          rcondv,
+          work,
+          lwork,
+          iwork,
+          info);
+#else
+  (void)balanc;
+  (void)jobvl;
+  (void)jobvr;
+  (void)sense;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)wr;
+  (void)wi;
+  (void)vl;
+  (void)ldvl;
+  (void)vr;
+  (void)ldvr;
+  (void)ilo;
+  (void)ihi;
+  (void)scale;
+  (void)abnrm;
+  (void)rconde;
+  (void)rcondv;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgeevx"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+geevx(const char *                   balanc,
+      const char *                   jobvl,
+      const char *                   jobvr,
+      const char *                   sense,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      double *                       wr,
+      double *                       wi,
+      double *                       vl,
+      const dealii::types::blas_int *ldvl,
+      double *                       vr,
+      const dealii::types::blas_int *ldvr,
+      dealii::types::blas_int *      ilo,
+      dealii::types::blas_int *      ihi,
+      double *                       scale,
+      double *                       abnrm,
+      double *                       rconde,
+      double *                       rcondv,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  dgeevx_(balanc,
+          jobvl,
+          jobvr,
+          sense,
+          n,
+          a,
+          lda,
+          wr,
+          wi,
+          vl,
+          ldvl,
+          vr,
+          ldvr,
+          ilo,
+          ihi,
+          scale,
+          abnrm,
+          rconde,
+          rcondv,
+          work,
+          lwork,
+          iwork,
+          info);
+#else
+  (void)balanc;
+  (void)jobvl;
+  (void)jobvr;
+  (void)sense;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)wr;
+  (void)wi;
+  (void)vl;
+  (void)ldvl;
+  (void)vr;
+  (void)ldvr;
+  (void)ilo;
+  (void)ihi;
+  (void)scale;
+  (void)abnrm;
+  (void)rconde;
+  (void)rcondv;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgeevx"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+geevx(const char *                   balanc,
+      const char *                   jobvl,
+      const char *                   jobvr,
+      const char *                   sense,
+      const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      std::complex<float> *          w,
+      std::complex<float> *          vl,
+      const dealii::types::blas_int *ldvl,
+      std::complex<float> *          vr,
+      const dealii::types::blas_int *ldvr,
+      dealii::types::blas_int *      ilo,
+      dealii::types::blas_int *      ihi,
+      float *                        scale,
+      float *                        abnrm,
+      float *                        rconde,
+      float *                        rcondv,
+      std::complex<float> *          work,
+      const dealii::types::blas_int *lwork,
+      float *                        rwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  cgeevx_(balanc,
+          jobvl,
+          jobvr,
+          sense,
+          n,
+          a,
+          lda,
+          w,
+          vl,
+          ldvl,
+          vr,
+          ldvr,
+          ilo,
+          ihi,
+          scale,
+          abnrm,
+          rconde,
+          rcondv,
+          work,
+          lwork,
+          rwork,
+          info);
+#else
+  (void)balanc;
+  (void)jobvl;
+  (void)jobvr;
+  (void)sense;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)w;
+  (void)vl;
+  (void)ldvl;
+  (void)vr;
+  (void)ldvr;
+  (void)ilo;
+  (void)ihi;
+  (void)scale;
+  (void)abnrm;
+  (void)rconde;
+  (void)rcondv;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgeevx"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+geevx(const char *                   balanc,
+      const char *                   jobvl,
+      const char *                   jobvr,
+      const char *                   sense,
+      const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      std::complex<double> *         w,
+      std::complex<double> *         vl,
+      const dealii::types::blas_int *ldvl,
+      std::complex<double> *         vr,
+      const dealii::types::blas_int *ldvr,
+      dealii::types::blas_int *      ilo,
+      dealii::types::blas_int *      ihi,
+      double *                       scale,
+      double *                       abnrm,
+      double *                       rconde,
+      double *                       rcondv,
+      std::complex<double> *         work,
+      const dealii::types::blas_int *lwork,
+      double *                       rwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  zgeevx_(balanc,
+          jobvl,
+          jobvr,
+          sense,
+          n,
+          a,
+          lda,
+          w,
+          vl,
+          ldvl,
+          vr,
+          ldvr,
+          ilo,
+          ihi,
+          scale,
+          abnrm,
+          rconde,
+          rcondv,
+          work,
+          lwork,
+          rwork,
+          info);
+#else
+  (void)balanc;
+  (void)jobvl;
+  (void)jobvr;
+  (void)sense;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)w;
+  (void)vl;
+  (void)ldvl;
+  (void)vr;
+  (void)ldvr;
+  (void)ilo;
+  (void)ihi;
+  (void)scale;
+  (void)abnrm;
+  (void)rconde;
+  (void)rcondv;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgeevx"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4,
+          typename number5>
+inline void
+gelsd(const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      number2 *,
+      const dealii::types::blas_int *,
+      number3 *,
+      const number4 *,
+      dealii::types::blas_int *,
+      number5 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *)
+{
+  Assert(false, ExcNotImplemented());
+}
+
+
+
+inline void
+gelsd(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      float *                        b,
+      const dealii::types::blas_int *ldb,
+      float *                        s,
+      const float *                  rcond,
+      dealii::types::blas_int *      rank,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgelsd_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info);
+#else
+  (void)m;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)s;
+  (void)rcond;
+  (void)rank;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgelsd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gelsd(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      double *                       b,
+      const dealii::types::blas_int *ldb,
+      double *                       s,
+      const double *                 rcond,
+      dealii::types::blas_int *      rank,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  dgelsd_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info);
+#else
+  (void)m;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)s;
+  (void)rcond;
+  (void)rank;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgelsd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gelsd(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      std::complex<float> *          b,
+      const dealii::types::blas_int *ldb,
+      float *                        s,
+      const float *                  rcond,
+      dealii::types::blas_int *      rank,
+      std::complex<float> *          work,
+      const dealii::types::blas_int *lwork,
+      float *                        rwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  cgelsd_(m,
+          n,
+          nrhs,
+          a,
+          lda,
+          b,
+          ldb,
+          s,
+          rcond,
+          rank,
+          work,
+          lwork,
+          rwork,
+          iwork,
+          info);
+#else
+  (void)m;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)s;
+  (void)rcond;
+  (void)rank;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgelsd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gelsd(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      std::complex<double> *         b,
+      const dealii::types::blas_int *ldb,
+      double *                       s,
+      const double *                 rcond,
+      dealii::types::blas_int *      rank,
+      std::complex<double> *         work,
+      const dealii::types::blas_int *lwork,
+      double *                       rwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  zgelsd_(m,
+          n,
+          nrhs,
+          a,
+          lda,
+          b,
+          ldb,
+          s,
+          rcond,
+          rank,
+          work,
+          lwork,
+          rwork,
+          iwork,
+          info);
+#else
+  (void)m;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)s;
+  (void)rcond;
+  (void)rank;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgelsd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4,
+          typename number5>
+inline void
+gemm(const char *,
+     const char *,
+     const dealii::types::blas_int *,
+     const dealii::types::blas_int *,
+     const dealii::types::blas_int *,
+     const number1 *,
+     const number2 *,
+     const dealii::types::blas_int *,
+     const number3 *,
+     const dealii::types::blas_int *,
+     const number4 *,
+     number5 *,
+     const dealii::types::blas_int *)
+{
+  Assert(false, ExcNotImplemented());
+}
+
+
+
+inline void
+gemm(const char *                   transa,
+     const char *                   transb,
+     const dealii::types::blas_int *m,
+     const dealii::types::blas_int *n,
+     const dealii::types::blas_int *k,
+     const float *                  alpha,
+     const float *                  a,
+     const dealii::types::blas_int *lda,
+     const float *                  b,
+     const dealii::types::blas_int *ldb,
+     const float *                  beta,
+     float *                        c,
+     const dealii::types::blas_int *ldc)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgemm_(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
+#else
+  (void)transa;
+  (void)transb;
+  (void)m;
+  (void)n;
+  (void)k;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)beta;
+  (void)c;
+  (void)ldc;
+  Assert(false, LAPACKSupport::ExcMissing("sgemm"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gemm(const char *                   transa,
+     const char *                   transb,
+     const dealii::types::blas_int *m,
+     const dealii::types::blas_int *n,
+     const dealii::types::blas_int *k,
+     const double *                 alpha,
+     const double *                 a,
+     const dealii::types::blas_int *lda,
+     const double *                 b,
+     const dealii::types::blas_int *ldb,
+     const double *                 beta,
+     double *                       c,
+     const dealii::types::blas_int *ldc)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  dgemm_(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
+#else
+  (void)transa;
+  (void)transb;
+  (void)m;
+  (void)n;
+  (void)k;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)beta;
+  (void)c;
+  (void)ldc;
+  Assert(false, LAPACKSupport::ExcMissing("dgemm"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gemm(const char *                   transa,
+     const char *                   transb,
+     const dealii::types::blas_int *m,
+     const dealii::types::blas_int *n,
+     const dealii::types::blas_int *k,
+     const std::complex<float> *    alpha,
+     const std::complex<float> *    a,
+     const dealii::types::blas_int *lda,
+     const std::complex<float> *    b,
+     const dealii::types::blas_int *ldb,
+     const std::complex<float> *    beta,
+     std::complex<float> *          c,
+     const dealii::types::blas_int *ldc)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  cgemm_(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
+#else
+  (void)transa;
+  (void)transb;
+  (void)m;
+  (void)n;
+  (void)k;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)beta;
+  (void)c;
+  (void)ldc;
+  Assert(false, LAPACKSupport::ExcMissing("cgemm"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gemm(const char *                   transa,
+     const char *                   transb,
+     const dealii::types::blas_int *m,
+     const dealii::types::blas_int *n,
+     const dealii::types::blas_int *k,
+     const std::complex<double> *   alpha,
+     const std::complex<double> *   a,
+     const dealii::types::blas_int *lda,
+     const std::complex<double> *   b,
+     const dealii::types::blas_int *ldb,
+     const std::complex<double> *   beta,
+     std::complex<double> *         c,
+     const dealii::types::blas_int *ldc)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  zgemm_(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
+#else
+  (void)transa;
+  (void)transb;
+  (void)m;
+  (void)n;
+  (void)k;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)beta;
+  (void)c;
+  (void)ldc;
+  Assert(false, LAPACKSupport::ExcMissing("zgemm"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4,
+          typename number5>
+inline void
+gemv(const char *,
+     const dealii::types::blas_int *,
+     const dealii::types::blas_int *,
+     const number1 *,
+     const number2 *,
+     const dealii::types::blas_int *,
+     const number3 *,
+     const dealii::types::blas_int *,
+     const number4 *,
+     number5 *,
+     const dealii::types::blas_int *)
+{
+  Assert(false, ExcNotImplemented());
+}
+
+
+
+inline void
+gemv(const char *                   trans,
+     const dealii::types::blas_int *m,
+     const dealii::types::blas_int *n,
+     const float *                  alpha,
+     const float *                  a,
+     const dealii::types::blas_int *lda,
+     const float *                  x,
+     const dealii::types::blas_int *incx,
+     const float *                  beta,
+     float *                        y,
+     const dealii::types::blas_int *incy)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgemv_(trans, m, n, alpha, a, lda, x, incx, beta, y, incy);
+#else
+  (void)trans;
+  (void)m;
+  (void)n;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)x;
+  (void)incx;
+  (void)beta;
+  (void)y;
+  (void)incy;
+  Assert(false, LAPACKSupport::ExcMissing("sgemv"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gemv(const char *                   trans,
+     const dealii::types::blas_int *m,
+     const dealii::types::blas_int *n,
+     const double *                 alpha,
+     const double *                 a,
+     const dealii::types::blas_int *lda,
+     const double *                 x,
+     const dealii::types::blas_int *incx,
+     const double *                 beta,
+     double *                       y,
+     const dealii::types::blas_int *incy)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  dgemv_(trans, m, n, alpha, a, lda, x, incx, beta, y, incy);
+#else
+  (void)trans;
+  (void)m;
+  (void)n;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)x;
+  (void)incx;
+  (void)beta;
+  (void)y;
+  (void)incy;
+  Assert(false, LAPACKSupport::ExcMissing("dgemv"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gemv(const char *                   trans,
+     const dealii::types::blas_int *m,
+     const dealii::types::blas_int *n,
+     const std::complex<float> *    alpha,
+     const std::complex<float> *    a,
+     const dealii::types::blas_int *lda,
+     const std::complex<float> *    x,
+     const dealii::types::blas_int *incx,
+     const std::complex<float> *    beta,
+     std::complex<float> *          y,
+     const dealii::types::blas_int *incy)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  cgemv_(trans, m, n, alpha, a, lda, x, incx, beta, y, incy);
+#else
+  (void)trans;
+  (void)m;
+  (void)n;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)x;
+  (void)incx;
+  (void)beta;
+  (void)y;
+  (void)incy;
+  Assert(false, LAPACKSupport::ExcMissing("cgemv"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gemv(const char *                   trans,
+     const dealii::types::blas_int *m,
+     const dealii::types::blas_int *n,
+     const std::complex<double> *   alpha,
+     const std::complex<double> *   a,
+     const dealii::types::blas_int *lda,
+     const std::complex<double> *   x,
+     const dealii::types::blas_int *incx,
+     const std::complex<double> *   beta,
+     std::complex<double> *         y,
+     const dealii::types::blas_int *incy)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  zgemv_(trans, m, n, alpha, a, lda, x, incx, beta, y, incy);
+#else
+  (void)trans;
+  (void)m;
+  (void)n;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)x;
+  (void)incx;
+  (void)beta;
+  (void)y;
+  (void)incy;
+  Assert(false, LAPACKSupport::ExcMissing("zgemv"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+template <typename number1, typename number2, typename number3>
+inline void
+geqrf(const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      number2 *,
+      number3 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
+{
+  Assert(false, ExcNotImplemented());
+}
+
+
+
+inline void
+geqrf(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      float *                        tau,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgeqrf_(m, n, a, lda, tau, work, lwork, info);
+#else
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)tau;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgeqrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-DEAL_II_NAMESPACE_OPEN
 
 
-/// Template wrapper for LAPACK functions dsyrk and ssyrk
-template <typename number>
 inline void
-syrk(const char *,
-     const char *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const number *,
-     const number *,
-     const types::blas_int *,
-     const number *,
-     number *,
-     const types::blas_int *)
+geqrf(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      double *                       tau,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, ExcNotImplemented());
+#ifdef DEAL_II_WITH_LAPACK
+  dgeqrf_(m, n, a, lda, tau, work, lwork, info);
+#else
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)tau;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgeqrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-syrk(const char *           uplo,
-     const char *           trans,
-     const types::blas_int *n,
-     const types::blas_int *k,
-     const double *         alpha,
-     const double *         A,
-     const types::blas_int *lda,
-     const double *         beta,
-     double *               C,
-     const types::blas_int *ldc)
+geqrf(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      std::complex<float> *          tau,
+      std::complex<float> *          work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
-  dsyrk_(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
+#ifdef DEAL_II_WITH_LAPACK
+  cgeqrf_(m, n, a, lda, tau, work, lwork, info);
+#else
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)tau;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgeqrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
+
+
 inline void
-syrk(const char *           uplo,
-     const char *           trans,
-     const types::blas_int *n,
-     const types::blas_int *k,
-     const float *          alpha,
-     const float *          A,
-     const types::blas_int *lda,
-     const float *          beta,
-     float *                C,
-     const types::blas_int *ldc)
+geqrf(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      std::complex<double> *         tau,
+      std::complex<double> *         work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
-  ssyrk_(uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
+#ifdef DEAL_II_WITH_LAPACK
+  zgeqrf_(m, n, a, lda, tau, work, lwork, info);
+#else
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)tau;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgeqrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
 
-/// Template wrapper for LAPACK functions dsyr and ssyr
-template <typename number>
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4,
+          typename number5>
 inline void
-syr(const char *,
-    const types::blas_int *,
-    const number *,
-    const number *,
-    const types::blas_int *,
-    number *,
-    const types::blas_int *)
+gesdd(const char *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      number2 *,
+      number3 *,
+      const dealii::types::blas_int *,
+      number4 *,
+      const dealii::types::blas_int *,
+      number5 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
+
+
+inline void
+gesdd(const char *                   jobz,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      float *                        s,
+      float *                        u,
+      const dealii::types::blas_int *ldu,
+      float *                        vt,
+      const dealii::types::blas_int *ldvt,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgesdd_(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info);
+#else
+  (void)jobz;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)s;
+  (void)u;
+  (void)ldu;
+  (void)vt;
+  (void)ldvt;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgesdd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gesdd(const char *                   jobz,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      double *                       s,
+      double *                       u,
+      const dealii::types::blas_int *ldu,
+      double *                       vt,
+      const dealii::types::blas_int *ldvt,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
+{
 #ifdef DEAL_II_WITH_LAPACK
+  dgesdd_(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info);
+#else
+  (void)jobz;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)s;
+  (void)u;
+  (void)ldu;
+  (void)vt;
+  (void)ldvt;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgesdd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-syr(const char *           uplo,
-    const types::blas_int *n,
-    const double *         alpha,
-    const double *         x,
-    const types::blas_int *incx,
-    double *               A,
-    const types::blas_int *lda)
+gesdd(const char *                   jobz,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      float *                        s,
+      std::complex<float> *          u,
+      const dealii::types::blas_int *ldu,
+      std::complex<float> *          vt,
+      const dealii::types::blas_int *ldvt,
+      std::complex<float> *          work,
+      const dealii::types::blas_int *lwork,
+      float *                        rwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
 {
-  dsyr_(uplo, n, alpha, x, incx, A, lda);
+#ifdef DEAL_II_WITH_LAPACK
+  cgesdd_(
+    jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info);
+#else
+  (void)jobz;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)s;
+  (void)u;
+  (void)ldu;
+  (void)vt;
+  (void)ldvt;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgesdd"));
+#endif // DEAL_II_WITH_LAPACK
 }
+
+
+
 inline void
-syr(const char *           uplo,
-    const types::blas_int *n,
-    const float *          alpha,
-    const float *          x,
-    const types::blas_int *incx,
-    float *                A,
-    const types::blas_int *lda)
+gesdd(const char *                   jobz,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      double *                       s,
+      std::complex<double> *         u,
+      const dealii::types::blas_int *ldu,
+      std::complex<double> *         vt,
+      const dealii::types::blas_int *ldvt,
+      std::complex<double> *         work,
+      const dealii::types::blas_int *lwork,
+      double *                       rwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
 {
-  ssyr_(uplo, n, alpha, x, incx, A, lda);
+#ifdef DEAL_II_WITH_LAPACK
+  zgesdd_(
+    jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info);
+#else
+  (void)jobz;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)s;
+  (void)u;
+  (void)ldu;
+  (void)vt;
+  (void)ldvt;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgesdd"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
 
-/// Template wrapper for LAPACK functions daxpy and saxpy
-template <typename number1, typename number2, typename number3>
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4,
+          typename number5>
 inline void
-axpy(const types::blas_int *,
-     const number1 *,
-     const number2 *,
-     const types::blas_int *,
-     number3 *,
-     const types::blas_int *)
+gesvd(const char *,
+      const char *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      number2 *,
+      number3 *,
+      const dealii::types::blas_int *,
+      number4 *,
+      const dealii::types::blas_int *,
+      number5 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
+
+
+inline void
+gesvd(const char *                   jobu,
+      const char *                   jobvt,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      float *                        s,
+      float *                        u,
+      const dealii::types::blas_int *ldu,
+      float *                        vt,
+      const dealii::types::blas_int *ldvt,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgesvd_(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info);
+#else
+  (void)jobu;
+  (void)jobvt;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)s;
+  (void)u;
+  (void)ldu;
+  (void)vt;
+  (void)ldvt;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgesvd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+gesvd(const char *                   jobu,
+      const char *                   jobvt,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      double *                       s,
+      double *                       u,
+      const dealii::types::blas_int *ldu,
+      double *                       vt,
+      const dealii::types::blas_int *ldvt,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
+{
 #ifdef DEAL_II_WITH_LAPACK
+  dgesvd_(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info);
+#else
+  (void)jobu;
+  (void)jobvt;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)s;
+  (void)u;
+  (void)ldu;
+  (void)vt;
+  (void)ldvt;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgesvd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-axpy(const types::blas_int *n,
-     const double *         alpha,
-     const double *         x,
-     const types::blas_int *incx,
-     double *               y,
-     const types::blas_int *incy)
+gesvd(const char *                   jobu,
+      const char *                   jobvt,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      float *                        s,
+      std::complex<float> *          u,
+      const dealii::types::blas_int *ldu,
+      std::complex<float> *          vt,
+      const dealii::types::blas_int *ldvt,
+      std::complex<float> *          work,
+      const dealii::types::blas_int *lwork,
+      float *                        rwork,
+      dealii::types::blas_int *      info)
 {
-  daxpy_(n, alpha, x, incx, y, incy);
+#ifdef DEAL_II_WITH_LAPACK
+  cgesvd_(
+    jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info);
+#else
+  (void)jobu;
+  (void)jobvt;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)s;
+  (void)u;
+  (void)ldu;
+  (void)vt;
+  (void)ldvt;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgesvd"));
+#endif // DEAL_II_WITH_LAPACK
 }
+
+
+
+inline void
+gesvd(const char *                   jobu,
+      const char *                   jobvt,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      double *                       s,
+      std::complex<double> *         u,
+      const dealii::types::blas_int *ldu,
+      std::complex<double> *         vt,
+      const dealii::types::blas_int *ldvt,
+      std::complex<double> *         work,
+      const dealii::types::blas_int *lwork,
+      double *                       rwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  zgesvd_(
+    jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info);
 #else
+  (void)jobu;
+  (void)jobvt;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)s;
+  (void)u;
+  (void)ldu;
+  (void)vt;
+  (void)ldvt;
+  (void)work;
+  (void)lwork;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgesvd"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+template <typename number1>
 inline void
-axpy(const types::blas_int *,
-     const double *,
-     const double *,
-     const types::blas_int *,
-     double *,
-     const types::blas_int *)
+getrf(const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
-  Assert(false, LAPACKSupport::ExcMissing("daxpy"));
+  Assert(false, ExcNotImplemented());
 }
-#endif
 
 
+
+inline void
+getrf(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      ipiv,
+      dealii::types::blas_int *      info)
+{
 #ifdef DEAL_II_WITH_LAPACK
+  sgetrf_(m, n, a, lda, ipiv, info);
+#else
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgetrf"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-axpy(const types::blas_int *n,
-     const float *          alpha,
-     const float *          x,
-     const types::blas_int *incx,
-     float *                y,
-     const types::blas_int *incy)
+getrf(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      ipiv,
+      dealii::types::blas_int *      info)
 {
-  saxpy_(n, alpha, x, incx, y, incy);
+#ifdef DEAL_II_WITH_LAPACK
+  dgetrf_(m, n, a, lda, ipiv, info);
+#else
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgetrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
+
+
+
+inline void
+getrf(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      ipiv,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  cgetrf_(m, n, a, lda, ipiv, info);
 #else
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgetrf"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-axpy(const types::blas_int *,
-     const float *,
-     const float *,
-     const types::blas_int *,
-     float *,
-     const types::blas_int *)
+getrf(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      ipiv,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("saxpy"));
+#ifdef DEAL_II_WITH_LAPACK
+  zgetrf_(m, n, a, lda, ipiv, info);
+#else
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgetrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dgemv and sgemv
-template <typename number1,
-          typename number2,
-          typename number3,
-          typename number4,
-          typename number5>
+
+template <typename number1, typename number2>
 inline void
-gemv(const char *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const number1 *,
-     const number2 *,
-     const types::blas_int *,
-     const number3 *,
-     const types::blas_int *,
-     const number4 *,
-     number5 *,
-     const types::blas_int *)
+getri(const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number2 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
+inline void
+getri(const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      const dealii::types::blas_int *ipiv,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  sgetri_(n, a, lda, ipiv, work, lwork, info);
+#else
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgetri"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+getri(const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      const dealii::types::blas_int *ipiv,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  dgetri_(n, a, lda, ipiv, work, lwork, info);
+#else
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgetri"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-gemv(const char *           trans,
-     const types::blas_int *m,
-     const types::blas_int *n,
-     const double *         alpha,
-     const double *         A,
-     const types::blas_int *lda,
-     const double *         x,
-     const types::blas_int *incx,
-     const double *         b,
-     double *               y,
-     const types::blas_int *incy)
+getri(const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      const dealii::types::blas_int *ipiv,
+      std::complex<float> *          work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
-  dgemv_(trans, m, n, alpha, A, lda, x, incx, b, y, incy);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  cgetri_(n, a, lda, ipiv, work, lwork, info);
 #else
-inline void
-gemv(const char *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const double *,
-     const double *,
-     const types::blas_int *,
-     const double *,
-     const types::blas_int *,
-     const double *,
-     double *,
-     const types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgemv"));
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgetri"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-gemv(const char *           trans,
-     const types::blas_int *m,
-     const types::blas_int *n,
-     const float *          alpha,
-     const float *          A,
-     const types::blas_int *lda,
-     const float *          x,
-     const types::blas_int *incx,
-     const float *          b,
-     float *                y,
-     const types::blas_int *incy)
+getri(const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      const dealii::types::blas_int *ipiv,
+      std::complex<double> *         work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
-  sgemv_(trans, m, n, alpha, A, lda, x, incx, b, y, incy);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  zgetri_(n, a, lda, ipiv, work, lwork, info);
 #else
-inline void
-gemv(const char *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const float *,
-     const float *,
-     const types::blas_int *,
-     const float *,
-     const types::blas_int *,
-     const float *,
-     float *,
-     const types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sgemv"));
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgetri"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
 
-/// Template wrapper for LAPACK functions dtrmv and strmv
-template <typename number>
+template <typename number1, typename number2>
 inline void
-trmv(const char * /*uplo*/,
-     const char * /*trans*/,
-     const char * /*diag*/,
-     const types::blas_int * /*N*/,
-     const number * /*A*/,
-     const types::blas_int * /*lda*/,
-     number * /*x*/,
-     const types::blas_int * /*incx*/)
+getrs(const char *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const number1 *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number2 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-trmv(const char *           uplo,
-     const char *           trans,
-     const char *           diag,
-     const types::blas_int *N,
-     const double *         A,
-     const types::blas_int *lda,
-     double *               x,
-     const types::blas_int *incx)
+getrs(const char *                   trans,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const float *                  a,
+      const dealii::types::blas_int *lda,
+      const dealii::types::blas_int *ipiv,
+      float *                        b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  dtrmv_(uplo, trans, diag, N, A, lda, x, incx);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  sgetrs_(trans, n, nrhs, a, lda, ipiv, b, ldb, info);
 #else
+  (void)trans;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sgetrs"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-trmv(const char * /*uplo*/,
-     const char * /*trans*/,
-     const char * /*diag*/,
-     const types::blas_int * /*N*/,
-     const double * /*A*/,
-     const types::blas_int * /*lda*/,
-     double * /*x*/,
-     const types::blas_int * /*incx*/)
+getrs(const char *                   trans,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const double *                 a,
+      const dealii::types::blas_int *lda,
+      const dealii::types::blas_int *ipiv,
+      double *                       b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("dtrmv"));
+#ifdef DEAL_II_WITH_LAPACK
+  dgetrs_(trans, n, nrhs, a, lda, ipiv, b, ldb, info);
+#else
+  (void)trans;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dgetrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-trmv(const char *           uplo,
-     const char *           trans,
-     const char *           diag,
-     const types::blas_int *N,
-     const float *          A,
-     const types::blas_int *lda,
-     float *                x,
-     const types::blas_int *incx)
+getrs(const char *                   trans,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const std::complex<float> *    a,
+      const dealii::types::blas_int *lda,
+      const dealii::types::blas_int *ipiv,
+      std::complex<float> *          b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  strmv_(uplo, trans, diag, N, A, lda, x, incx);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  cgetrs_(trans, n, nrhs, a, lda, ipiv, b, ldb, info);
 #else
+  (void)trans;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cgetrs"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-trmv(const char * /*uplo*/,
-     const char * /*trans*/,
-     const char * /*diag*/,
-     const types::blas_int * /*N*/,
-     const float * /*A*/,
-     const types::blas_int * /*lda*/,
-     float * /*x*/,
-     const types::blas_int * /*incx*/)
+getrs(const char *                   trans,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const std::complex<double> *   a,
+      const dealii::types::blas_int *lda,
+      const dealii::types::blas_int *ipiv,
+      std::complex<double> *         b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("dtrmv"));
+#ifdef DEAL_II_WITH_LAPACK
+  zgetrs_(trans, n, nrhs, a, lda, ipiv, b, ldb, info);
+#else
+  (void)trans;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)ipiv;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zgetrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
 
-/// Template wrapper for LAPACK functions dgemm and sgemm
-template <typename number1,
-          typename number2,
-          typename number3,
-          typename number4,
-          typename number5>
-inline void
-gemm(const char *,
-     const char *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const number1 *,
-     const number2 *,
-     const types::blas_int *,
-     const number3 *,
-     const types::blas_int *,
-     const number4 *,
-     number5 *,
-     const types::blas_int *)
+template <typename number1>
+inline number1
+lamch(const char *)
 {
   Assert(false, ExcNotImplemented());
+  return number1();
 }
 
-#ifdef DEAL_II_WITH_LAPACK
-inline void
-gemm(const char *           transa,
-     const char *           transb,
-     const types::blas_int *m,
-     const types::blas_int *n,
-     const types::blas_int *k,
-     const double *         alpha,
-     const double *         A,
-     const types::blas_int *lda,
-     const double *         B,
-     const types::blas_int *ldb,
-     const double *         beta,
-     double *               C,
-     const types::blas_int *ldc)
+
+
+template <>
+inline float
+lamch(const char *cmach)
 {
-  dgemm_(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  return slamch_(cmach);
 #else
-inline void
-gemm(const char *,
-     const char *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const double *,
-     const double *,
-     const types::blas_int *,
-     const double *,
-     const types::blas_int *,
-     const double *,
-     double *,
-     const types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgemm"));
+  (void)cmach;
+  Assert(false, LAPACKSupport::ExcMissing("slamch"));
+  return float();
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
-inline void
-gemm(const char *           transa,
-     const char *           transb,
-     const types::blas_int *m,
-     const types::blas_int *n,
-     const types::blas_int *k,
-     const float *          alpha,
-     const float *          A,
-     const types::blas_int *lda,
-     const float *          B,
-     const types::blas_int *ldb,
-     const float *          beta,
-     float *                C,
-     const types::blas_int *ldc)
+
+template <>
+inline double
+lamch(const char *cmach)
 {
-  sgemm_(transa, transb, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  return dlamch_(cmach);
 #else
-inline void
-gemm(const char *,
-     const char *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const types::blas_int *,
-     const float *,
-     const float *,
-     const types::blas_int *,
-     const float *,
-     const types::blas_int *,
-     const float *,
-     float *,
-     const types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sgemm"));
+  (void)cmach;
+  Assert(false, LAPACKSupport::ExcMissing("dlamch"));
+  return double();
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
 
-/// Template wrapper for potrf
-template <typename number1>
-inline void
-potrf(const char *,
-      const types::blas_int *,
-      number1 *,
-      const types::blas_int *,
-      types::blas_int *)
+template <typename number1, typename number2>
+inline number1
+lange(const char *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const number1 *,
+      const dealii::types::blas_int *,
+      number2 *)
 {
   Assert(false, ExcNotImplemented());
+  return number1();
 }
 
-inline void
-potrf(const char *           uplo,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      types::blas_int *      info)
+
+
+inline float
+lange(const char *                   norm,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const float *                  a,
+      const dealii::types::blas_int *lda,
+      float *                        work)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  dpotrf_(uplo, n, A, lda, info);
+  return slange_(norm, m, n, a, lda, work);
 #else
-  (void)uplo;
+  (void)norm;
+  (void)m;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
-  (void)info;
-
-  Assert(false, LAPACKSupport::ExcMissing("dpotrf"));
-#endif
+  (void)work;
+  Assert(false, LAPACKSupport::ExcMissing("slange"));
+  return float();
+#endif // DEAL_II_WITH_LAPACK
 }
 
-inline void
-potrf(const char *           uplo,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      types::blas_int *      info)
+
+
+inline double
+lange(const char *                   norm,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const double *                 a,
+      const dealii::types::blas_int *lda,
+      double *                       work)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  spotrf_(uplo, n, A, lda, info);
+  return dlange_(norm, m, n, a, lda, work);
 #else
-  (void)uplo;
+  (void)norm;
+  (void)m;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
-  (void)info;
-
-  Assert(false, LAPACKSupport::ExcMissing("spotrf"));
-#endif
+  (void)work;
+  Assert(false, LAPACKSupport::ExcMissing("dlange"));
+  return double();
+#endif // DEAL_II_WITH_LAPACK
 }
 
 
 
-/// Template wrapper for trcon
-template <typename number>
-inline void
-trcon(const char * /*norm*/,
-      const char * /*uplo*/,
-      const char * /*diag*/,
-      const types::blas_int * /*n*/,
-      const number * /*A*/,
-      const types::blas_int * /*lda*/,
-      number * /*rcond*/,
-      number * /*work*/,
-      types::blas_int * /*iwork*/,
-      types::blas_int * /*info*/)
+inline float
+lange(const char *                   norm,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const std::complex<float> *    a,
+      const dealii::types::blas_int *lda,
+      float *                        work)
 {
-  Assert(false, ExcNotImplemented());
+#ifdef DEAL_II_WITH_LAPACK
+  return clange_(norm, m, n, a, lda, work);
+#else
+  (void)norm;
+  (void)m;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)work;
+  Assert(false, LAPACKSupport::ExcMissing("clange"));
+  return float();
+#endif // DEAL_II_WITH_LAPACK
 }
 
-inline void
-trcon(const char *           norm,
-      const char *           uplo,
-      const char *           diag,
-      const types::blas_int *n,
-      const double *         A,
-      const types::blas_int *lda,
-      double *               rcond,
-      double *               work,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+
+
+inline double
+lange(const char *                   norm,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const std::complex<double> *   a,
+      const dealii::types::blas_int *lda,
+      double *                       work)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  dtrcon_(norm, uplo, diag, n, A, lda, rcond, work, iwork, info);
+  return zlange_(norm, m, n, a, lda, work);
 #else
   (void)norm;
-  (void)uplo;
-  (void)diag;
+  (void)m;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
-  (void)rcond;
   (void)work;
-  (void)iwork;
-  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zlange"));
+  return double();
+#endif // DEAL_II_WITH_LAPACK
+}
 
-  Assert(false, LAPACKSupport::ExcMissing("dtrcon"));
-#endif
+
+
+template <typename number1, typename number2>
+inline number1
+lansy(const char *,
+      const char *,
+      const dealii::types::blas_int *,
+      const number1 *,
+      const dealii::types::blas_int *,
+      number2 *)
+{
+  Assert(false, ExcNotImplemented());
+  return number1();
 }
 
-inline void
-trcon(const char *           norm,
-      const char *           uplo,
-      const char *           diag,
-      const types::blas_int *n,
-      const float *          A,
-      const types::blas_int *lda,
-      float *                rcond,
-      float *                work,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+
+
+inline float
+lansy(const char *                   norm,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const float *                  a,
+      const dealii::types::blas_int *lda,
+      float *                        work)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  strcon_(norm, uplo, diag, n, A, lda, rcond, work, iwork, info);
+  return slansy_(norm, uplo, n, a, lda, work);
 #else
   (void)norm;
   (void)uplo;
-  (void)diag;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
-  (void)rcond;
   (void)work;
-  (void)iwork;
-  (void)info;
-
-  Assert(false, LAPACKSupport::ExcMissing("dtrcon"));
-#endif
+  Assert(false, LAPACKSupport::ExcMissing("slansy"));
+  return float();
+#endif // DEAL_II_WITH_LAPACK
 }
 
 
 
-/// Template wrapper for pocon
-template <typename number1>
-inline void
-pocon(const char *,
-      const types::blas_int *,
-      const number1 *,
-      const types::blas_int *,
-      const number1 *,
-      number1 *,
-      number1 *,
-      types::blas_int *,
-      types::blas_int *)
+inline double
+lansy(const char *                   norm,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const double *                 a,
+      const dealii::types::blas_int *lda,
+      double *                       work)
 {
-  Assert(false, ExcNotImplemented());
+#ifdef DEAL_II_WITH_LAPACK
+  return dlansy_(norm, uplo, n, a, lda, work);
+#else
+  (void)norm;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)work;
+  Assert(false, LAPACKSupport::ExcMissing("dlansy"));
+  return double();
+#endif // DEAL_II_WITH_LAPACK
 }
 
-inline void
-pocon(const char *           uplo,
-      const types::blas_int *n,
-      const double *         A,
-      const types::blas_int *lda,
-      const double *         anorm,
-      double *               rcond,
-      double *               work,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+
+
+inline float
+lansy(const char *                   norm,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const std::complex<float> *    a,
+      const dealii::types::blas_int *lda,
+      float *                        work)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  dpocon_(uplo, n, A, lda, anorm, rcond, work, iwork, info);
+  return clansy_(norm, uplo, n, a, lda, work);
 #else
+  (void)norm;
   (void)uplo;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
-  (void)anorm;
-  (void)rcond;
   (void)work;
-  (void)iwork;
-  (void)info;
-
-  Assert(false, LAPACKSupport::ExcMissing("dpocon"));
-#endif
+  Assert(false, LAPACKSupport::ExcMissing("clansy"));
+  return float();
+#endif // DEAL_II_WITH_LAPACK
 }
 
-inline void
-pocon(const char *           uplo,
-      const types::blas_int *n,
-      const float *          A,
-      const types::blas_int *lda,
-      const float *          anorm,
-      float *                rcond,
-      float *                work,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+
+
+inline double
+lansy(const char *                   norm,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const std::complex<double> *   a,
+      const dealii::types::blas_int *lda,
+      double *                       work)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  spocon_(uplo, n, A, lda, anorm, rcond, work, iwork, info);
+  return zlansy_(norm, uplo, n, a, lda, work);
 #else
+  (void)norm;
   (void)uplo;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
-  (void)anorm;
-  (void)rcond;
   (void)work;
-  (void)iwork;
-  (void)info;
-
-  Assert(false, LAPACKSupport::ExcMissing("dpocon"));
-#endif
+  Assert(false, LAPACKSupport::ExcMissing("zlansy"));
+  return double();
+#endif // DEAL_II_WITH_LAPACK
 }
 
-/// Template wrapper for potri
-template <typename number1>
+
+
+template <typename number1, typename number2, typename number3>
 inline void
-potri(const char *,
-      const types::blas_int *,
-      number1 *,
-      const types::blas_int *,
-      types::blas_int *)
+lascl(const char *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const number1 *,
+      const number2 *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number3 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
+
+
 inline void
-potri(const char *           uplo,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      types::blas_int *      info)
+lascl(const char *                   type,
+      const dealii::types::blas_int *kl,
+      const dealii::types::blas_int *ku,
+      const float *                  cfrom,
+      const float *                  cto,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  dpotri_(uplo, n, A, lda, info);
+  slascl_(type, kl, ku, cfrom, cto, m, n, a, lda, info);
 #else
-  (void)uplo;
+  (void)type;
+  (void)kl;
+  (void)ku;
+  (void)cfrom;
+  (void)cto;
+  (void)m;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
   (void)info;
-
-  Assert(false, LAPACKSupport::ExcMissing("dpotri"));
-#endif
+  Assert(false, LAPACKSupport::ExcMissing("slascl"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
+
+
 inline void
-potri(const char *           uplo,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      types::blas_int *      info)
+lascl(const char *                   type,
+      const dealii::types::blas_int *kl,
+      const dealii::types::blas_int *ku,
+      const double *                 cfrom,
+      const double *                 cto,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  spotri_(uplo, n, A, lda, info);
+  dlascl_(type, kl, ku, cfrom, cto, m, n, a, lda, info);
 #else
-  (void)uplo;
+  (void)type;
+  (void)kl;
+  (void)ku;
+  (void)cfrom;
+  (void)cto;
+  (void)m;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
   (void)info;
-
-  Assert(false, LAPACKSupport::ExcMissing("spotri"));
-#endif
+  Assert(false, LAPACKSupport::ExcMissing("dlascl"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
 
-/// Template wrapper for lansy
-template <typename number>
-inline number
-lansy(const char *,
-      const char *,
-      const types::blas_int *,
-      const number *,
-      const types::blas_int *,
-      number *)
-{
-  Assert(false, ExcNotImplemented());
-  return number();
-}
 
-inline double
-lansy(const char *           norm,
-      const char *           uplo,
-      const types::blas_int *n,
-      const double *         A,
-      const types::blas_int *lda,
-      double *               work)
+inline void
+lascl(const char *                   type,
+      const dealii::types::blas_int *kl,
+      const dealii::types::blas_int *ku,
+      const float *                  cfrom,
+      const float *                  cto,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  return dlansy_(norm, uplo, n, A, lda, work);
+  clascl_(type, kl, ku, cfrom, cto, m, n, a, lda, info);
 #else
-  (void)norm;
-  (void)uplo;
+  (void)type;
+  (void)kl;
+  (void)ku;
+  (void)cfrom;
+  (void)cto;
+  (void)m;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
-  (void)work;
-
-  Assert(false, LAPACKSupport::ExcMissing("lansy"));
-  return 0.;
-#endif
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("clascl"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-inline float
-lansy(const char *           norm,
-      const char *           uplo,
-      const types::blas_int *n,
-      const float *          A,
-      const types::blas_int *lda,
-      float *                work)
+
+
+inline void
+lascl(const char *                   type,
+      const dealii::types::blas_int *kl,
+      const dealii::types::blas_int *ku,
+      const double *                 cfrom,
+      const double *                 cto,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  return slansy_(norm, uplo, n, A, lda, work);
+  zlascl_(type, kl, ku, cfrom, cto, m, n, a, lda, info);
 #else
-  (void)norm;
-  (void)uplo;
+  (void)type;
+  (void)kl;
+  (void)ku;
+  (void)cfrom;
+  (void)cto;
+  (void)m;
   (void)n;
-  (void)A;
+  (void)a;
   (void)lda;
-  (void)work;
-
-  Assert(false, LAPACKSupport::ExcMissing("lansy"));
-  return 0.;
-#endif
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zlascl"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
 
 
-/// Template wrapper for lange
-template <typename number>
-inline number
-lange(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const number *,
-      const types::blas_int *,
-      number *)
+template <typename number1, typename number2, typename number3>
+inline void
+orgqr(const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      const number2 *,
+      number3 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
-  return number();
 }
 
-inline double
-lange(const char *           norm,
-      const types::blas_int *m,
-      const types::blas_int *n,
-      const double *         A,
-      const types::blas_int *lda,
-      double *               work)
+
+
+inline void
+orgqr(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *k,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      const float *                  tau,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  return dlange_(norm, m, n, A, lda, work);
+  sorgqr_(m, n, k, a, lda, tau, work, lwork, info);
 #else
-  (void)norm;
   (void)m;
   (void)n;
-  (void)A;
+  (void)k;
+  (void)a;
   (void)lda;
+  (void)tau;
   (void)work;
-
-  Assert(false, LAPACKSupport::ExcMissing("lange"));
-  return 0.;
-#endif
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sorgqr"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-inline float
-lange(const char *           norm,
-      const types::blas_int *m,
-      const types::blas_int *n,
-      const float *          A,
-      const types::blas_int *lda,
-      float *                work)
+
+
+inline void
+orgqr(const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *k,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      const double *                 tau,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
 #ifdef DEAL_II_WITH_LAPACK
-  return slange_(norm, m, n, A, lda, work);
+  dorgqr_(m, n, k, a, lda, tau, work, lwork, info);
 #else
-  (void)norm;
   (void)m;
   (void)n;
-  (void)A;
+  (void)k;
+  (void)a;
   (void)lda;
+  (void)tau;
   (void)work;
-
-  Assert(false, LAPACKSupport::ExcMissing("lange"));
-  return 0.;
-#endif
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dorgqr"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-/// Template wrapper for LAPACK functions dgetrf and sgetrf
-template <typename number1>
+
+
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4>
 inline void
-getrf(const types::blas_int *,
-      const types::blas_int *,
-      number1 *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+ormqr(const char *,
+      const char *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const number1 *,
+      const dealii::types::blas_int *,
+      const number2 *,
+      number3 *,
+      const dealii::types::blas_int *,
+      number4 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-getrf(const types::blas_int *m,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      types::blas_int *      ipiv,
-      types::blas_int *      info)
+ormqr(const char *                   side,
+      const char *                   trans,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *k,
+      const float *                  a,
+      const dealii::types::blas_int *lda,
+      const float *                  tau,
+      float *                        c,
+      const dealii::types::blas_int *ldc,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
-  dgetrf_(m, n, A, lda, ipiv, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  sormqr_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info);
 #else
-inline void
-getrf(const types::blas_int *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgetrf"));
+  (void)side;
+  (void)trans;
+  (void)m;
+  (void)n;
+  (void)k;
+  (void)a;
+  (void)lda;
+  (void)tau;
+  (void)c;
+  (void)ldc;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sormqr"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-getrf(const types::blas_int *m,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      types::blas_int *      ipiv,
-      types::blas_int *      info)
+ormqr(const char *                   side,
+      const char *                   trans,
+      const dealii::types::blas_int *m,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *k,
+      const double *                 a,
+      const dealii::types::blas_int *lda,
+      const double *                 tau,
+      double *                       c,
+      const dealii::types::blas_int *ldc,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      info)
 {
-  sgetrf_(m, n, A, lda, ipiv, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  dormqr_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info);
 #else
-inline void
-getrf(const types::blas_int *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sgetrf"));
+  (void)side;
+  (void)trans;
+  (void)m;
+  (void)n;
+  (void)k;
+  (void)a;
+  (void)lda;
+  (void)tau;
+  (void)c;
+  (void)ldc;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dormqr"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dgetrs and sgetrs
-template <typename number1, typename number2>
+
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4>
 inline void
-getrs(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
+pocon(const char *,
+      const dealii::types::blas_int *,
       const number1 *,
-      const types::blas_int *,
-      const types::blas_int *,
-      number2 *,
-      const types::blas_int *,
-      types::blas_int *)
+      const dealii::types::blas_int *,
+      const number2 *,
+      number3 *,
+      number4 *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
-inline void
-getrs(const char *           trans,
-      const types::blas_int *n,
-      const types::blas_int *nrhs,
-      const double *         A,
-      const types::blas_int *lda,
-      const types::blas_int *ipiv,
-      double *               b,
-      const types::blas_int *ldb,
-      types::blas_int *      info)
-{
-  dgetrs_(trans, n, nrhs, A, lda, ipiv, b, ldb, info);
-}
-#else
-inline void
-getrs(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      const types::blas_int *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgetrs"));
-}
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
 inline void
-getrs(const char *           trans,
-      const types::blas_int *n,
-      const types::blas_int *nrhs,
-      const float *          A,
-      const types::blas_int *lda,
-      const types::blas_int *ipiv,
-      float *                b,
-      const types::blas_int *ldb,
-      types::blas_int *      info)
+pocon(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const float *                  a,
+      const dealii::types::blas_int *lda,
+      const float *                  anorm,
+      float *                        rcond,
+      float *                        work,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
 {
-  sgetrs_(trans, n, nrhs, A, lda, ipiv, b, ldb, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  spocon_(uplo, n, a, lda, anorm, rcond, work, iwork, info);
 #else
-inline void
-getrs(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      const types::blas_int *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sgetrs"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)anorm;
+  (void)rcond;
+  (void)work;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("spocon"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
 
-///  Template wrapper for LAPACK functions dpotrs and spotrs
-template <typename number>
 inline void
-potrs(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const number *,
-      const types::blas_int *,
-      number *,
-      const types::blas_int *,
-      types::blas_int *)
+pocon(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const double *                 a,
+      const dealii::types::blas_int *lda,
+      const double *                 anorm,
+      double *                       rcond,
+      double *                       work,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, ExcNotImplemented());
-}
-
 #ifdef DEAL_II_WITH_LAPACK
-inline void
-potrs(const char *           uplo,
-      const types::blas_int *n,
-      const types::blas_int *nrhs,
-      const double *         A,
-      const types::blas_int *lda,
-      double *               B,
-      const types::blas_int *ldb,
-      types::blas_int *      info)
-{
-  dpotrs_(uplo, n, nrhs, A, lda, B, ldb, info);
-}
-inline void
-potrs(const char *           uplo,
-      const types::blas_int *n,
-      const types::blas_int *nrhs,
-      const float *          A,
-      const types::blas_int *lda,
-      float *                B,
-      const types::blas_int *ldb,
-      types::blas_int *      info)
-{
-  spotrs_(uplo, n, nrhs, A, lda, B, ldb, info);
-}
+  dpocon_(uplo, n, a, lda, anorm, rcond, work, iwork, info);
 #else
-inline void
-potrs(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dpotrs"));
-}
-inline void
-potrs(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("spotrs"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)anorm;
+  (void)rcond;
+  (void)work;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dpocon"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
 
-/// Template wrapper for LAPACK functions dgetri and sgetri
-template <typename number1, typename number2>
 inline void
-getri(const types::blas_int *,
-      number1 *,
-      const types::blas_int *,
-      types::blas_int *,
-      number2 *,
-      const types::blas_int *,
-      types::blas_int *)
+pocon(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const std::complex<float> *    a,
+      const dealii::types::blas_int *lda,
+      const float *                  anorm,
+      float *                        rcond,
+      std::complex<float> *          work,
+      float *                        rwork,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, ExcNotImplemented());
-}
-
 #ifdef DEAL_II_WITH_LAPACK
-inline void
-getri(const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      types::blas_int *      ipiv,
-      double *               inv_work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
-{
-  dgetri_(n, A, lda, ipiv, inv_work, lwork, info);
-}
+  cpocon_(uplo, n, a, lda, anorm, rcond, work, rwork, info);
 #else
-inline void
-getri(const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgetri"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)anorm;
+  (void)rcond;
+  (void)work;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cpocon"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-getri(const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      types::blas_int *      ipiv,
-      float *                inv_work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+pocon(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const std::complex<double> *   a,
+      const dealii::types::blas_int *lda,
+      const double *                 anorm,
+      double *                       rcond,
+      std::complex<double> *         work,
+      double *                       rwork,
+      dealii::types::blas_int *      info)
 {
-  sgetri_(n, A, lda, ipiv, inv_work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  zpocon_(uplo, n, a, lda, anorm, rcond, work, rwork, info);
 #else
-inline void
-getri(const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sgetri"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)anorm;
+  (void)rcond;
+  (void)work;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zpocon"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dgeqrf and sgeqrf
-template <typename number1, typename number2, typename number3>
+
+template <typename number1>
 inline void
-geqrf(const types::blas_int *,
-      const types::blas_int *,
+potrf(const char *,
+      const dealii::types::blas_int *,
       number1 *,
-      const types::blas_int *,
-      number2 *,
-      number3 *,
-      const types::blas_int *,
-      types::blas_int *)
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-geqrf(const types::blas_int *m,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      double *               tau,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+potrf(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
-  dgeqrf_(m, n, A, lda, tau, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  spotrf_(uplo, n, a, lda, info);
 #else
-inline void
-geqrf(const types::blas_int *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      double *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgeqrf"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("spotrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-geqrf(const types::blas_int *m,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      float *                tau,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+potrf(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
-  sgeqrf_(m, n, A, lda, tau, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  dpotrf_(uplo, n, a, lda, info);
 #else
-inline void
-geqrf(const types::blas_int *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      float *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sgeqrf"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dpotrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dormqr and sormqr
-template <typename number1,
-          typename number2,
-          typename number3,
-          typename number4>
+
 inline void
-ormqr(const char *,
-      const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const number1 *,
-      const types::blas_int *,
-      const number2 *,
-      number3 *,
-      const types::blas_int *,
-      number4 *,
-      const types::blas_int *,
-      types::blas_int *)
+potrf(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, ExcNotImplemented());
+#ifdef DEAL_II_WITH_LAPACK
+  cpotrf_(uplo, n, a, lda, info);
+#else
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cpotrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-ormqr(const char *           side,
-      const char *           trans,
-      const types::blas_int *m,
-      const types::blas_int *n,
-      const types::blas_int *k,
-      const double *         A,
-      const types::blas_int *lda,
-      const double *         tau,
-      double *               B,
-      const types::blas_int *ldb,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+potrf(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
-  dormqr_(side, trans, m, n, k, A, lda, tau, B, ldb, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  zpotrf_(uplo, n, a, lda, info);
 #else
-inline void
-ormqr(const char *,
-      const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      const types::blas_int *,
-      const double *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dormqr"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zpotrf"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
+template <typename number1>
 inline void
-ormqr(const char *           side,
-      const char *           trans,
-      const types::blas_int *m,
-      const types::blas_int *n,
-      const types::blas_int *k,
-      const float *          A,
-      const types::blas_int *lda,
-      const float *          tau,
-      float *                B,
-      const types::blas_int *ldb,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+potri(const char *,
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
-  sormqr_(side, trans, m, n, k, A, lda, tau, B, ldb, work, lwork, info);
+  Assert(false, ExcNotImplemented());
 }
-#else
+
+
+
 inline void
-ormqr(const char *,
-      const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      const types::blas_int *,
-      const float *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
+potri(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("sormqr"));
+#ifdef DEAL_II_WITH_LAPACK
+  spotri_(uplo, n, a, lda, info);
+#else
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("spotri"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dorgqr and sorgqr
-template <typename number1, typename number2, typename number3>
+
 inline void
-orgqr(const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const number1 *,
-      const types::blas_int *,
-      const number2 *,
-      number3 *,
-      const types::blas_int *,
-      types::blas_int *)
+potri(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, ExcNotImplemented());
+#ifdef DEAL_II_WITH_LAPACK
+  dpotri_(uplo, n, a, lda, info);
+#else
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dpotri"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-orgqr(const types::blas_int *m,
-      const types::blas_int *n,
-      const types::blas_int *k,
-      const double *         A,
-      const types::blas_int *lda,
-      const double *         tau,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+potri(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      std::complex<float> *          a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
-  dorgqr_(m, n, k, A, lda, tau, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  cpotri_(uplo, n, a, lda, info);
 #else
-inline void
-orgqr(const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      const types::blas_int *,
-      const double *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dorgqr"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cpotri"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-orgqr(const types::blas_int *m,
-      const types::blas_int *n,
-      const types::blas_int *k,
-      const float *          A,
-      const types::blas_int *lda,
-      const float *          tau,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+potri(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      std::complex<double> *         a,
+      const dealii::types::blas_int *lda,
+      dealii::types::blas_int *      info)
 {
-  sorgqr_(m, n, k, A, lda, tau, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  zpotri_(uplo, n, a, lda, info);
 #else
-inline void
-orgqr(const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      const types::blas_int *,
-      const float *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sorgqr"));
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zpotri"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dtrtrs and strtrs
+
 template <typename number1, typename number2>
 inline void
-trtrs(const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      const types::blas_int *,
+potrs(const char *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
       const number1 *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
       number2 *,
-      const types::blas_int *,
-      types::blas_int *)
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-trtrs(const char *           uplo,
-      const char *           trans,
-      const char *           diag,
-      const types::blas_int *n,
-      const types::blas_int *n_rhs,
-      const double *         A,
-      const types::blas_int *lda,
-      double *               B,
-      const types::blas_int *ldb,
-      types::blas_int *      info)
+potrs(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const float *                  a,
+      const dealii::types::blas_int *lda,
+      float *                        b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  dtrtrs_(uplo, trans, diag, n, n_rhs, A, lda, B, ldb, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  spotrs_(uplo, n, nrhs, a, lda, b, ldb, info);
 #else
-inline void
-trtrs(const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dtrtrs"));
+  (void)uplo;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("spotrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-trtrs(const char *           uplo,
-      const char *           trans,
-      const char *           diag,
-      const types::blas_int *n,
-      const types::blas_int *n_rhs,
-      const float *          A,
-      const types::blas_int *lda,
-      float *                B,
-      const types::blas_int *ldb,
-      types::blas_int *      info)
+potrs(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const double *                 a,
+      const dealii::types::blas_int *lda,
+      double *                       b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  strtrs_(uplo, trans, diag, n, n_rhs, A, lda, B, ldb, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  dpotrs_(uplo, n, nrhs, a, lda, b, ldb, info);
 #else
-inline void
-trtrs(const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("strtrs"));
+  (void)uplo;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dpotrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dgeev and sgeev
-template <typename number1,
-          typename number2,
-          typename number3,
-          typename number4,
-          typename number5,
-          typename number6>
+
 inline void
-geev(const char *,
-     const char *,
-     const types::blas_int *,
-     number1 *,
-     const types::blas_int *,
-     number2 *,
-     number3 *,
-     number4 *,
-     const types::blas_int *,
-     number5 *,
-     const types::blas_int *,
-     number6 *,
-     const types::blas_int *,
-     types::blas_int *)
+potrs(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const std::complex<float> *    a,
+      const dealii::types::blas_int *lda,
+      std::complex<float> *          b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, ExcNotImplemented());
-}
-
 #ifdef DEAL_II_WITH_LAPACK
-inline void
-geev(const char *           jobvl,
-     const char *           jobvr,
-     const types::blas_int *n,
-     double *               A,
-     const types::blas_int *lda,
-     double *               lambda_re,
-     double *               lambda_im,
-     double *               vl,
-     const types::blas_int *ldvl,
-     double *               vr,
-     const types::blas_int *ldva,
-     double *               work,
-     const types::blas_int *lwork,
-     types::blas_int *      info)
-{
-  dgeev_(jobvl,
-         jobvr,
-         n,
-         A,
-         lda,
-         lambda_re,
-         lambda_im,
-         vl,
-         ldvl,
-         vr,
-         ldva,
-         work,
-         lwork,
-         info);
-}
+  cpotrs_(uplo, n, nrhs, a, lda, b, ldb, info);
 #else
-inline void
-geev(const char *,
-     const char *,
-     const types::blas_int *,
-     double *,
-     const types::blas_int *,
-     double *,
-     double *,
-     double *,
-     const types::blas_int *,
-     double *,
-     const types::blas_int *,
-     double *,
-     const types::blas_int *,
-     types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgeev"));
+  (void)uplo;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("cpotrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
-inline void
-geev(const char *           jobvl,
-     const char *           jobvr,
-     const types::blas_int *n,
-     float *                A,
-     const types::blas_int *lda,
-     float *                lambda_re,
-     float *                lambda_im,
-     float *                vl,
-     const types::blas_int *ldvl,
-     float *                vr,
-     const types::blas_int *ldva,
-     float *                work,
-     const types::blas_int *lwork,
-     types::blas_int *      info)
-{
-  sgeev_(jobvl,
-         jobvr,
-         n,
-         A,
-         lda,
-         lambda_re,
-         lambda_im,
-         vl,
-         ldvl,
-         vr,
-         ldva,
-         work,
-         lwork,
-         info);
-}
-#else
+
 inline void
-geev(const char *,
-     const char *,
-     const types::blas_int *,
-     float *,
-     const types::blas_int *,
-     float *,
-     float *,
-     float *,
-     const types::blas_int *,
-     float *,
-     const types::blas_int *,
-     float *,
-     const types::blas_int *,
-     types::blas_int *)
+potrs(const char *                   uplo,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const std::complex<double> *   a,
+      const dealii::types::blas_int *lda,
+      std::complex<double> *         b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("sgeev"));
+#ifdef DEAL_II_WITH_LAPACK
+  zpotrs_(uplo, n, nrhs, a, lda, b, ldb, info);
+#else
+  (void)uplo;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("zpotrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dgeevx and sgeevx
+
 template <typename number1,
           typename number2,
           typename number3,
-          typename number4,
-          typename number5,
-          typename number6,
-          typename number7,
-          typename number8,
-          typename number9,
-          typename number10>
+          typename number4>
 inline void
-geevx(const char *,
-      const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      number1 *,
-      const types::blas_int *,
-      number2 *,
-      number3 *,
-      number4 *,
-      const types::blas_int *,
-      number5 *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      number6 *,
-      number7 *,
-      number8 *,
-      number9 *,
-      number10 *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+stev(const char *,
+     const dealii::types::blas_int *,
+     number1 *,
+     number2 *,
+     number3 *,
+     const dealii::types::blas_int *,
+     number4 *,
+     dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-geevx(const char *           balanc,
-      const char *           jobvl,
-      const char *           jobvr,
-      const char *           sense,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      double *               lambda_re,
-      double *               lambda_im,
-      double *               vl,
-      const types::blas_int *ldvl,
-      double *               vr,
-      const types::blas_int *ldvr,
-      types::blas_int *      ilo,
-      types::blas_int *      ihi,
-      double *               scale,
-      double *               abnrm,
-      double *               rconde,
-      double *               rcondv,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+stev(const char *                   jobz,
+     const dealii::types::blas_int *n,
+     float *                        d,
+     float *                        e,
+     float *                        z,
+     const dealii::types::blas_int *ldz,
+     float *                        work,
+     dealii::types::blas_int *      info)
 {
-  dgeevx_(balanc,
-          jobvl,
-          jobvr,
-          sense,
-          n,
-          A,
-          lda,
-          lambda_re,
-          lambda_im,
-          vl,
-          ldvl,
-          vr,
-          ldvr,
-          ilo,
-          ihi,
-          scale,
-          abnrm,
-          rconde,
-          rcondv,
-          work,
-          lwork,
-          iwork,
-          info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  sstev_(jobz, n, d, e, z, ldz, work, info);
 #else
-inline void
-geevx(const char *,
-      const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      double *,
-      double *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      double *,
-      double *,
-      double *,
-      double *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgeevx"));
+  (void)jobz;
+  (void)n;
+  (void)d;
+  (void)e;
+  (void)z;
+  (void)ldz;
+  (void)work;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("sstev"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-geevx(const char *           balanc,
-      const char *           jobvl,
-      const char *           jobvr,
-      const char *           sense,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      float *                lambda_re,
-      float *                lambda_im,
-      float *                vl,
-      const types::blas_int *ldvl,
-      float *                vr,
-      const types::blas_int *ldvr,
-      types::blas_int *      ilo,
-      types::blas_int *      ihi,
-      float *                scale,
-      float *                abnrm,
-      float *                rconde,
-      float *                rcondv,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+stev(const char *                   jobz,
+     const dealii::types::blas_int *n,
+     double *                       d,
+     double *                       e,
+     double *                       z,
+     const dealii::types::blas_int *ldz,
+     double *                       work,
+     dealii::types::blas_int *      info)
 {
-  sgeevx_(balanc,
-          jobvl,
-          jobvr,
-          sense,
-          n,
-          A,
-          lda,
-          lambda_re,
-          lambda_im,
-          vl,
-          ldvl,
-          vr,
-          ldvr,
-          ilo,
-          ihi,
-          scale,
-          abnrm,
-          rconde,
-          rcondv,
-          work,
-          lwork,
-          iwork,
-          info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  dstev_(jobz, n, d, e, z, ldz, work, info);
 #else
-inline void
-geevx(const char *,
-      const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      float *,
-      float *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      float *,
-      float *,
-      float *,
-      float *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sgeevx"));
+  (void)jobz;
+  (void)n;
+  (void)d;
+  (void)e;
+  (void)z;
+  (void)ldz;
+  (void)work;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dstev"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dsyev and ssyev
+
 template <typename number1, typename number2, typename number3>
 inline void
 syev(const char *,
      const char *,
-     const types::blas_int *,
+     const dealii::types::blas_int *,
      number1 *,
-     const types::blas_int *,
+     const dealii::types::blas_int *,
      number2 *,
      number3 *,
-     const types::blas_int *,
-     types::blas_int *)
+     const dealii::types::blas_int *,
+     dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-syev(const char *           jobz,
-     const char *           uplo,
-     const types::blas_int *n,
-     double *               A,
-     const types::blas_int *lda,
-     double *               w,
-     double *               work,
-     const types::blas_int *lwork,
-     types::blas_int *      info)
+syev(const char *                   jobz,
+     const char *                   uplo,
+     const dealii::types::blas_int *n,
+     float *                        a,
+     const dealii::types::blas_int *lda,
+     float *                        w,
+     float *                        work,
+     const dealii::types::blas_int *lwork,
+     dealii::types::blas_int *      info)
 {
-  dsyev_(jobz, uplo, n, A, lda, w, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  ssyev_(jobz, uplo, n, a, lda, w, work, lwork, info);
 #else
-inline void
-syev(const char *,
-     const char *,
-     const types::blas_int *,
-     double *,
-     const types::blas_int *,
-     double *,
-     double *,
-     const types::blas_int *,
-     types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dsyev"));
+  (void)jobz;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)w;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ssyev"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-syev(const char *           jobz,
-     const char *           uplo,
-     const types::blas_int *n,
-     float *                A,
-     const types::blas_int *lda,
-     float *                w,
-     float *                work,
-     const types::blas_int *lwork,
-     types::blas_int *      info)
+syev(const char *                   jobz,
+     const char *                   uplo,
+     const dealii::types::blas_int *n,
+     double *                       a,
+     const dealii::types::blas_int *lda,
+     double *                       w,
+     double *                       work,
+     const dealii::types::blas_int *lwork,
+     dealii::types::blas_int *      info)
 {
-  ssyev_(jobz, uplo, n, A, lda, w, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  dsyev_(jobz, uplo, n, a, lda, w, work, lwork, info);
 #else
-inline void
-syev(const char *,
-     const char *,
-     const types::blas_int *,
-     float *,
-     const types::blas_int *,
-     float *,
-     float *,
-     const types::blas_int *,
-     types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("ssyev"));
+  (void)jobz;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)w;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dsyev"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dsyevx and ssyevx
+
 template <typename number1,
           typename number2,
           typename number3,
@@ -2682,58 +4636,70 @@ template <typename number1,
           typename number6,
           typename number7>
 inline void
-syevx(const char *,
+syevr(const char *,
       const char *,
       const char *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
       number1 *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
       const number2 *,
       const number3 *,
-      const types::blas_int *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
       const number4 *,
-      types::blas_int *,
+      dealii::types::blas_int *,
       number5 *,
       number6 *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
       number7 *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-syevx(const char *           jobz,
-      const char *           range,
-      const char *           uplo,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      const double *         vl,
-      const double *         vu,
-      const types::blas_int *il,
-      const types::blas_int *iu,
-      const double *         abstol,
-      types::blas_int *      m,
-      double *               w,
-      double *               z,
-      const types::blas_int *ldz,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      ifail,
-      types::blas_int *      info)
+syevr(const char *                   jobz,
+      const char *                   range,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      const float *                  vl,
+      const float *                  vu,
+      const dealii::types::blas_int *il,
+      const dealii::types::blas_int *iu,
+      const float *                  abstol,
+      dealii::types::blas_int *      m,
+      float *                        w,
+      float *                        z,
+      const dealii::types::blas_int *ldz,
+      dealii::types::blas_int *      isuppz,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      const dealii::types::blas_int *liwork,
+      dealii::types::blas_int *      info)
 {
-  dsyevx_(jobz,
+#ifdef DEAL_II_WITH_LAPACK
+  // Netlib and Atlas Lapack perform floating point tests (e.g. divide-by-zero)
+  // within calls to some functions, which cause floating point exceptions to be
+  // thrown (at least in debug mode). Therefore, we wrap the calls into the
+  // following code to suppress the exception.
+#  ifdef DEAL_II_HAVE_FP_EXCEPTIONS
+  fenv_t fp_exceptions;
+  feholdexcept(&fp_exceptions);
+#  endif // DEAL_II_HAVE_FP_EXCEPTIONS
+  ssyevr_(jobz,
           range,
           uplo,
           n,
-          A,
+          a,
           lda,
           vl,
           vu,
@@ -2744,68 +4710,80 @@ syevx(const char *           jobz,
           w,
           z,
           ldz,
+          isuppz,
           work,
           lwork,
           iwork,
-          ifail,
+          liwork,
           info);
-}
+#  ifdef DEAL_II_HAVE_FP_EXCEPTIONS
+  fesetenv(&fp_exceptions);
+#  endif // DEAL_II_HAVE_FP_EXCEPTIONS
 #else
-inline void
-syevx(const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      const double *,
-      const double *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      types::blas_int *,
-      double *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+  (void)jobz;
+  (void)range;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)vl;
+  (void)vu;
+  (void)il;
+  (void)iu;
+  (void)abstol;
+  (void)m;
+  (void)w;
+  (void)z;
+  (void)ldz;
+  (void)isuppz;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)liwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ssyevr"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+syevr(const char *                   jobz,
+      const char *                   range,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      const double *                 vl,
+      const double *                 vu,
+      const dealii::types::blas_int *il,
+      const dealii::types::blas_int *iu,
+      const double *                 abstol,
+      dealii::types::blas_int *      m,
+      double *                       w,
+      double *                       z,
+      const dealii::types::blas_int *ldz,
+      dealii::types::blas_int *      isuppz,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      const dealii::types::blas_int *liwork,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("dsyevx"));
-}
-#endif
-
-
 #ifdef DEAL_II_WITH_LAPACK
-inline void
-syevx(const char *           jobz,
-      const char *           range,
-      const char *           uplo,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      const float *          vl,
-      const float *          vu,
-      const types::blas_int *il,
-      const types::blas_int *iu,
-      const float *          abstol,
-      types::blas_int *      m,
-      float *                w,
-      float *                z,
-      const types::blas_int *ldz,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      ifail,
-      types::blas_int *      info)
-{
-  ssyevx_(jobz,
+  // Netlib and Atlas Lapack perform floating point tests (e.g. divide-by-zero)
+  // within calls to some functions, which cause floating point exceptions to be
+  // thrown (at least in debug mode). Therefore, we wrap the calls into the
+  // following code to suppress the exception.
+#  ifdef DEAL_II_HAVE_FP_EXCEPTIONS
+  fenv_t fp_exceptions;
+  feholdexcept(&fp_exceptions);
+#  endif // DEAL_II_HAVE_FP_EXCEPTIONS
+  dsyevr_(jobz,
           range,
           uplo,
           n,
-          A,
+          a,
           lda,
           vl,
           vu,
@@ -2816,109 +4794,105 @@ syevx(const char *           jobz,
           w,
           z,
           ldz,
+          isuppz,
           work,
           lwork,
           iwork,
-          ifail,
+          liwork,
           info);
-}
+#  ifdef DEAL_II_HAVE_FP_EXCEPTIONS
+  fesetenv(&fp_exceptions);
+#  endif // DEAL_II_HAVE_FP_EXCEPTIONS
 #else
+  (void)jobz;
+  (void)range;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)vl;
+  (void)vu;
+  (void)il;
+  (void)iu;
+  (void)abstol;
+  (void)m;
+  (void)w;
+  (void)z;
+  (void)ldz;
+  (void)isuppz;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)liwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dsyevr"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+template <typename number1,
+          typename number2,
+          typename number3,
+          typename number4,
+          typename number5,
+          typename number6,
+          typename number7>
 inline void
 syevx(const char *,
       const char *,
       const char *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      const float *,
-      const float *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      types::blas_int *,
-      float *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("ssyevx"));
-}
-#endif
-
-
-// Template wrapper for LAPACK functions dsyevr and ssyevr
-template <typename number>
-inline void
-syevr(const char * /*jobz*/,
-      const char * /*range*/,
-      const char * /*uplo*/,
-      const types::blas_int * /*n*/,
-      number * /*A*/,
-      const types::blas_int * /*lda*/,
-      const number * /*vl*/,
-      const number * /*vu*/,
-      const types::blas_int * /*il*/,
-      const types::blas_int * /*iu*/,
-      const number * /*abstol*/,
-      types::blas_int * /*m*/,
-      number * /*w*/,
-      number * /*z*/,
-      const types::blas_int * /*ldz*/,
-      types::blas_int * /*isuppz*/,
-      number * /*work*/,
-      types::blas_int * /*lwork*/,
-      types::blas_int * /*iwork*/,
-      types::blas_int * /*liwork*/,
-      types::blas_int * /*info*/)
+      const dealii::types::blas_int *,
+      number1 *,
+      const dealii::types::blas_int *,
+      const number2 *,
+      const number3 *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const number4 *,
+      dealii::types::blas_int *,
+      number5 *,
+      number6 *,
+      const dealii::types::blas_int *,
+      number7 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
 
-#ifdef DEAL_II_WITH_LAPACK
-inline void
-syevr(const char *           jobz,
-      const char *           range,
-      const char *           uplo,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      const double *         vl,
-      const double *         vu,
-      const types::blas_int *il,
-      const types::blas_int *iu,
-      const double *         abstol,
-      types::blas_int *      m,
-      double *               w,
-      double *               z,
-      const types::blas_int *ldz,
-      types::blas_int *      isuppz,
-      double *               work,
-      types::blas_int *      lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      liwork,
-      types::blas_int *      info)
-{
-  /*
-   * Netlib and Atlas Lapack perform floating point tests (e.g. divide-by-zero)
-   * within the call to dsyevr causing floating point exceptions to be thrown
-   * (at least in debug mode). Therefore, we wrap the calls to dsyevr into the
-   * following code to suppress the exception.
-   */
-#  ifdef DEAL_II_HAVE_FP_EXCEPTIONS
-  fenv_t fp_exceptions;
-  feholdexcept(&fp_exceptions);
-#  endif
 
-  dsyevr_(jobz,
+inline void
+syevx(const char *                   jobz,
+      const char *                   range,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      const float *                  vl,
+      const float *                  vu,
+      const dealii::types::blas_int *il,
+      const dealii::types::blas_int *iu,
+      const float *                  abstol,
+      dealii::types::blas_int *      m,
+      float *                        w,
+      float *                        z,
+      const dealii::types::blas_int *ldz,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      ifail,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  ssyevx_(jobz,
           range,
           uplo,
           n,
-          A,
+          a,
           lda,
           vl,
           vu,
@@ -2929,57 +4903,66 @@ syevr(const char *           jobz,
           w,
           z,
           ldz,
-          isuppz,
           work,
           lwork,
           iwork,
-          liwork,
+          ifail,
           info);
+#else
+  (void)jobz;
+  (void)range;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)vl;
+  (void)vu;
+  (void)il;
+  (void)iu;
+  (void)abstol;
+  (void)m;
+  (void)w;
+  (void)z;
+  (void)ldz;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)ifail;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ssyevx"));
+#endif // DEAL_II_WITH_LAPACK
+}
 
-#  ifdef DEAL_II_HAVE_FP_EXCEPTIONS
-  fesetenv(&fp_exceptions);
-#  endif
-}
-
-inline void
-syevr(const char *           jobz,
-      const char *           range,
-      const char *           uplo,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      const float *          vl,
-      const float *          vu,
-      const types::blas_int *il,
-      const types::blas_int *iu,
-      const float *          abstol,
-      types::blas_int *      m,
-      float *                w,
-      float *                z,
-      const types::blas_int *ldz,
-      types::blas_int *      isuppz,
-      float *                work,
-      types::blas_int *      lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      liwork,
-      types::blas_int *      info)
-{
-  /*
-   * Netlib and Atlas Lapack perform floating point tests (e.g. divide-by-zero)
-   * within the call to ssyevr causing floating point exceptions to be thrown
-   * (at least in debug mode). Therefore, we wrap the calls to ssyevr into the
-   * following code to suppress the exception.
-   */
-#  ifdef DEAL_II_HAVE_FP_EXCEPTIONS
-  fenv_t fp_exceptions;
-  feholdexcept(&fp_exceptions);
-#  endif
 
-  ssyevr_(jobz,
+
+inline void
+syevx(const char *                   jobz,
+      const char *                   range,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      const double *                 vl,
+      const double *                 vu,
+      const dealii::types::blas_int *il,
+      const dealii::types::blas_int *iu,
+      const double *                 abstol,
+      dealii::types::blas_int *      m,
+      double *                       w,
+      double *                       z,
+      const dealii::types::blas_int *ldz,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      ifail,
+      dealii::types::blas_int *      info)
+{
+#ifdef DEAL_II_WITH_LAPACK
+  dsyevx_(jobz,
           range,
           uplo,
           n,
-          A,
+          a,
           lda,
           vl,
           vu,
@@ -2990,117 +4973,131 @@ syevr(const char *           jobz,
           w,
           z,
           ldz,
-          isuppz,
           work,
           lwork,
           iwork,
-          liwork,
+          ifail,
           info);
-
-#  ifdef DEAL_II_HAVE_FP_EXCEPTIONS
-  fesetenv(&fp_exceptions);
-#  endif
+#else
+  (void)jobz;
+  (void)range;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)vl;
+  (void)vu;
+  (void)il;
+  (void)iu;
+  (void)abstol;
+  (void)m;
+  (void)w;
+  (void)z;
+  (void)ldz;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)ifail;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dsyevx"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dsygv and ssygv
+
 template <typename number1,
           typename number2,
           typename number3,
           typename number4>
 inline void
-sygv(const types::blas_int *,
+sygv(const dealii::types::blas_int *,
      const char *,
      const char *,
-     const types::blas_int *,
+     const dealii::types::blas_int *,
      number1 *,
-     const types::blas_int *,
+     const dealii::types::blas_int *,
      number2 *,
-     const types::blas_int *,
+     const dealii::types::blas_int *,
      number3 *,
      number4 *,
-     const types::blas_int *,
-     types::blas_int *)
+     const dealii::types::blas_int *,
+     dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-sygv(const types::blas_int *itype,
-     const char *           jobz,
-     const char *           uplo,
-     const types::blas_int *n,
-     double *               A,
-     const types::blas_int *lda,
-     double *               B,
-     const types::blas_int *ldb,
-     double *               w,
-     double *               work,
-     const types::blas_int *lwork,
-     types::blas_int *      info)
+sygv(const dealii::types::blas_int *itype,
+     const char *                   jobz,
+     const char *                   uplo,
+     const dealii::types::blas_int *n,
+     float *                        a,
+     const dealii::types::blas_int *lda,
+     float *                        b,
+     const dealii::types::blas_int *ldb,
+     float *                        w,
+     float *                        work,
+     const dealii::types::blas_int *lwork,
+     dealii::types::blas_int *      info)
 {
-  dsygv_(itype, jobz, uplo, n, A, lda, B, ldb, w, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  ssygv_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info);
 #else
-inline void
-sygv(const types::blas_int *,
-     const char *,
-     const char *,
-     const types::blas_int *,
-     double *,
-     const types::blas_int *,
-     double *,
-     const types::blas_int *,
-     double *,
-     double *,
-     const types::blas_int *,
-     types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dsygv"));
+  (void)itype;
+  (void)jobz;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)w;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ssygv"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-sygv(const types::blas_int *itype,
-     const char *           jobz,
-     const char *           uplo,
-     const types::blas_int *n,
-     float *                A,
-     const types::blas_int *lda,
-     float *                B,
-     const types::blas_int *ldb,
-     float *                w,
-     float *                work,
-     const types::blas_int *lwork,
-     types::blas_int *      info)
+sygv(const dealii::types::blas_int *itype,
+     const char *                   jobz,
+     const char *                   uplo,
+     const dealii::types::blas_int *n,
+     double *                       a,
+     const dealii::types::blas_int *lda,
+     double *                       b,
+     const dealii::types::blas_int *ldb,
+     double *                       w,
+     double *                       work,
+     const dealii::types::blas_int *lwork,
+     dealii::types::blas_int *      info)
 {
-  ssygv_(itype, jobz, uplo, n, A, lda, B, ldb, w, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  dsygv_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info);
 #else
-inline void
-sygv(const types::blas_int *,
-     const char *,
-     const char *,
-     const types::blas_int *,
-     float *,
-     const types::blas_int *,
-     float *,
-     const types::blas_int *,
-     float *,
-     float *,
-     const types::blas_int *,
-     types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("ssygv"));
+  (void)itype;
+  (void)jobz;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)w;
+  (void)work;
+  (void)lwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dsygv"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dsygvx and ssygvx
+
 template <typename number1,
           typename number2,
           typename number3,
@@ -3110,67 +5107,69 @@ template <typename number1,
           typename number7,
           typename number8>
 inline void
-sygvx(const types::blas_int *,
+sygvx(const dealii::types::blas_int *,
       const char *,
       const char *,
       const char *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
       number1 *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
       number2 *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
       const number3 *,
       const number4 *,
-      const types::blas_int *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
       const number5 *,
-      types::blas_int *,
+      dealii::types::blas_int *,
       number6 *,
       number7 *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
       number8 *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-sygvx(const types::blas_int *itype,
-      const char *           jobz,
-      const char *           range,
-      const char *           uplo,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      double *               B,
-      const types::blas_int *ldb,
-      const double *         vl,
-      const double *         vu,
-      const types::blas_int *il,
-      const types::blas_int *iu,
-      const double *         abstol,
-      types::blas_int *      m,
-      double *               w,
-      double *               z,
-      const types::blas_int *ldz,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      ifail,
-      types::blas_int *      info)
+sygvx(const dealii::types::blas_int *itype,
+      const char *                   jobz,
+      const char *                   range,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      float *                        a,
+      const dealii::types::blas_int *lda,
+      float *                        b,
+      const dealii::types::blas_int *ldb,
+      const float *                  vl,
+      const float *                  vu,
+      const dealii::types::blas_int *il,
+      const dealii::types::blas_int *iu,
+      const float *                  abstol,
+      dealii::types::blas_int *      m,
+      float *                        w,
+      float *                        z,
+      const dealii::types::blas_int *ldz,
+      float *                        work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      ifail,
+      dealii::types::blas_int *      info)
 {
-  dsygvx_(itype,
+#ifdef DEAL_II_WITH_LAPACK
+  ssygvx_(itype,
           jobz,
           range,
           uplo,
           n,
-          A,
+          a,
           lda,
-          B,
+          b,
           ldb,
           vl,
           vu,
@@ -3186,72 +5185,70 @@ sygvx(const types::blas_int *itype,
           iwork,
           ifail,
           info);
-}
 #else
-inline void
-sygvx(const types::blas_int *,
-      const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      const double *,
-      const double *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      types::blas_int *,
-      double *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+  (void)itype;
+  (void)jobz;
+  (void)range;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)vl;
+  (void)vu;
+  (void)il;
+  (void)iu;
+  (void)abstol;
+  (void)m;
+  (void)w;
+  (void)z;
+  (void)ldz;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)ifail;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ssygvx"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
+inline void
+sygvx(const dealii::types::blas_int *itype,
+      const char *                   jobz,
+      const char *                   range,
+      const char *                   uplo,
+      const dealii::types::blas_int *n,
+      double *                       a,
+      const dealii::types::blas_int *lda,
+      double *                       b,
+      const dealii::types::blas_int *ldb,
+      const double *                 vl,
+      const double *                 vu,
+      const dealii::types::blas_int *il,
+      const dealii::types::blas_int *iu,
+      const double *                 abstol,
+      dealii::types::blas_int *      m,
+      double *                       w,
+      double *                       z,
+      const dealii::types::blas_int *ldz,
+      double *                       work,
+      const dealii::types::blas_int *lwork,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      ifail,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("dsygvx"));
-}
-#endif
-
-
 #ifdef DEAL_II_WITH_LAPACK
-inline void
-sygvx(const types::blas_int *itype,
-      const char *           jobz,
-      const char *           range,
-      const char *           uplo,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      float *                B,
-      const types::blas_int *ldb,
-      const float *          vl,
-      const float *          vu,
-      const types::blas_int *il,
-      const types::blas_int *iu,
-      const float *          abstol,
-      types::blas_int *      m,
-      float *                w,
-      float *                z,
-      const types::blas_int *ldz,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      ifail,
-      types::blas_int *      info)
-{
-  ssygvx_(itype,
+  dsygvx_(itype,
           jobz,
           range,
           uplo,
           n,
-          A,
+          a,
           lda,
-          B,
+          b,
           ldb,
           vl,
           vu,
@@ -3267,539 +5264,651 @@ sygvx(const types::blas_int *itype,
           iwork,
           ifail,
           info);
-}
 #else
-inline void
-sygvx(const types::blas_int *,
-      const char *,
-      const char *,
-      const char *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      const float *,
-      const float *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      types::blas_int *,
-      float *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("ssygvx"));
+  (void)itype;
+  (void)jobz;
+  (void)range;
+  (void)uplo;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)vl;
+  (void)vu;
+  (void)il;
+  (void)iu;
+  (void)abstol;
+  (void)m;
+  (void)w;
+  (void)z;
+  (void)ldz;
+  (void)work;
+  (void)lwork;
+  (void)iwork;
+  (void)ifail;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dsygvx"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dgesdd and sgesdd
-template <typename number1,
-          typename number2,
-          typename number3,
-          typename number4,
-          typename number5>
+
+template <typename number1, typename number2, typename number3>
 inline void
-gesdd(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      number1 *,
-      const types::blas_int *,
-      number2 *,
-      number3 *,
-      const types::blas_int *,
-      number4 *,
-      const types::blas_int *,
-      number5 *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+syr(const char *,
+    const dealii::types::blas_int *,
+    const number1 *,
+    const number2 *,
+    const dealii::types::blas_int *,
+    number3 *,
+    const dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-gesdd(const char *           jobz,
-      const types::blas_int *m,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      double *               s,
-      double *               u,
-      const types::blas_int *ldu,
-      double *               vt,
-      const types::blas_int *ldvt,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+syr(const char *                   uplo,
+    const dealii::types::blas_int *n,
+    const float *                  alpha,
+    const float *                  x,
+    const dealii::types::blas_int *incx,
+    float *                        a,
+    const dealii::types::blas_int *lda)
 {
-  dgesdd_(jobz, m, n, A, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  ssyr_(uplo, n, alpha, x, incx, a, lda);
 #else
-inline void
-gesdd(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      double *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dgesdd"));
+  (void)uplo;
+  (void)n;
+  (void)alpha;
+  (void)x;
+  (void)incx;
+  (void)a;
+  (void)lda;
+  Assert(false, LAPACKSupport::ExcMissing("ssyr"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-gesdd(const char *           jobz,
-      const types::blas_int *m,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      float *                s,
-      float *                u,
-      const types::blas_int *ldu,
-      float *                vt,
-      const types::blas_int *ldvt,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+syr(const char *                   uplo,
+    const dealii::types::blas_int *n,
+    const double *                 alpha,
+    const double *                 x,
+    const dealii::types::blas_int *incx,
+    double *                       a,
+    const dealii::types::blas_int *lda)
 {
-  sgesdd_(jobz, m, n, A, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  dsyr_(uplo, n, alpha, x, incx, a, lda);
 #else
-inline void
-gesdd(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      float *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sgesdd"));
+  (void)uplo;
+  (void)n;
+  (void)alpha;
+  (void)x;
+  (void)incx;
+  (void)a;
+  (void)lda;
+  Assert(false, LAPACKSupport::ExcMissing("dsyr"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dgesvd and sgesvd
+
 template <typename number1,
           typename number2,
           typename number3,
-          typename number4,
-          typename number5>
+          typename number4>
 inline void
-gesvd(types::blas_int *,
-      types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      number1 *,
-      const types::blas_int *,
-      number2 *,
-      number3 *,
-      const types::blas_int *,
-      number4 *,
-      const types::blas_int *,
-      number5 *,
-      const types::blas_int *,
-      types::blas_int *)
+syrk(const char *,
+     const char *,
+     const dealii::types::blas_int *,
+     const dealii::types::blas_int *,
+     const number1 *,
+     const number2 *,
+     const dealii::types::blas_int *,
+     const number3 *,
+     number4 *,
+     const dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-gesvd(types::blas_int *      jobu,
-      types::blas_int *      jobvt,
-      const types::blas_int *n,
-      const types::blas_int *m,
-      double *               A,
-      const types::blas_int *lda,
-      double *               s,
-      double *               u,
-      const types::blas_int *ldu,
-      double *               vt,
-      const types::blas_int *ldvt,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+syrk(const char *                   uplo,
+     const char *                   trans,
+     const dealii::types::blas_int *n,
+     const dealii::types::blas_int *k,
+     const float *                  alpha,
+     const float *                  a,
+     const dealii::types::blas_int *lda,
+     const float *                  beta,
+     float *                        c,
+     const dealii::types::blas_int *ldc)
 {
-  dgesvd_(jobu, jobvt, n, m, A, lda, s, u, ldu, vt, ldvt, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  ssyrk_(uplo, trans, n, k, alpha, a, lda, beta, c, ldc);
 #else
+  (void)uplo;
+  (void)trans;
+  (void)n;
+  (void)k;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)beta;
+  (void)c;
+  (void)ldc;
+  Assert(false, LAPACKSupport::ExcMissing("ssyrk"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-gesvd(types::blas_int *,
-      types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      double *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
+syrk(const char *                   uplo,
+     const char *                   trans,
+     const dealii::types::blas_int *n,
+     const dealii::types::blas_int *k,
+     const double *                 alpha,
+     const double *                 a,
+     const dealii::types::blas_int *lda,
+     const double *                 beta,
+     double *                       c,
+     const dealii::types::blas_int *ldc)
 {
-  Assert(false, LAPACKSupport::ExcMissing("dgesvd"));
+#ifdef DEAL_II_WITH_LAPACK
+  dsyrk_(uplo, trans, n, k, alpha, a, lda, beta, c, ldc);
+#else
+  (void)uplo;
+  (void)trans;
+  (void)n;
+  (void)k;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)beta;
+  (void)c;
+  (void)ldc;
+  Assert(false, LAPACKSupport::ExcMissing("dsyrk"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-gesvd(types::blas_int *      jobu,
-      types::blas_int *      jobvt,
-      const types::blas_int *n,
-      const types::blas_int *m,
-      float *                A,
-      const types::blas_int *lda,
-      float *                s,
-      float *                u,
-      const types::blas_int *ldu,
-      float *                vt,
-      const types::blas_int *ldvt,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      info)
+syrk(const char *                   uplo,
+     const char *                   trans,
+     const dealii::types::blas_int *n,
+     const dealii::types::blas_int *k,
+     const std::complex<float> *    alpha,
+     const std::complex<float> *    a,
+     const dealii::types::blas_int *lda,
+     const std::complex<float> *    beta,
+     std::complex<float> *          c,
+     const dealii::types::blas_int *ldc)
 {
-  sgesvd_(jobu, jobvt, n, m, A, lda, s, u, ldu, vt, ldvt, work, lwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  csyrk_(uplo, trans, n, k, alpha, a, lda, beta, c, ldc);
 #else
+  (void)uplo;
+  (void)trans;
+  (void)n;
+  (void)k;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)beta;
+  (void)c;
+  (void)ldc;
+  Assert(false, LAPACKSupport::ExcMissing("csyrk"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-gesvd(types::blas_int *,
-      types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      float *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
+syrk(const char *                   uplo,
+     const char *                   trans,
+     const dealii::types::blas_int *n,
+     const dealii::types::blas_int *k,
+     const std::complex<double> *   alpha,
+     const std::complex<double> *   a,
+     const dealii::types::blas_int *lda,
+     const std::complex<double> *   beta,
+     std::complex<double> *         c,
+     const dealii::types::blas_int *ldc)
 {
-  Assert(false, LAPACKSupport::ExcMissing("sgesvd"));
+#ifdef DEAL_II_WITH_LAPACK
+  zsyrk_(uplo, trans, n, k, alpha, a, lda, beta, c, ldc);
+#else
+  (void)uplo;
+  (void)trans;
+  (void)n;
+  (void)k;
+  (void)alpha;
+  (void)a;
+  (void)lda;
+  (void)beta;
+  (void)c;
+  (void)ldc;
+  Assert(false, LAPACKSupport::ExcMissing("zsyrk"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dgelsd and sgelsd
-template <typename number1,
-          typename number2,
-          typename number3,
-          typename number4,
-          typename number5>
+
+template <typename number1, typename number2, typename number3>
 inline void
-gelsd(const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
+trcon(const char *,
+      const char *,
+      const char *,
+      const dealii::types::blas_int *,
       const number1 *,
-      const types::blas_int *,
+      const dealii::types::blas_int *,
       number2 *,
-      const types::blas_int *,
       number3 *,
-      const number4 *,
-      types::blas_int *,
-      number5 *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+      dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-gelsd(const types::blas_int *m,
-      const types::blas_int *n,
-      const types::blas_int *nrhs,
-      const double *         A,
-      const types::blas_int *lda,
-      double *               B,
-      const types::blas_int *ldb,
-      double *               s,
-      const double *         rcond,
-      types::blas_int *      rank,
-      double *               work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+trcon(const char *                   norm,
+      const char *                   uplo,
+      const char *                   diag,
+      const dealii::types::blas_int *n,
+      const float *                  a,
+      const dealii::types::blas_int *lda,
+      float *                        rcond,
+      float *                        work,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
 {
-  dgelsd_(m, n, nrhs, A, lda, B, ldb, s, rcond, rank, work, lwork, iwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  strcon_(norm, uplo, diag, n, a, lda, rcond, work, iwork, info);
 #else
+  (void)norm;
+  (void)uplo;
+  (void)diag;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)rcond;
+  (void)work;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("strcon"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-gelsd(const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      double *,
-      const double *,
-      types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+trcon(const char *                   norm,
+      const char *                   uplo,
+      const char *                   diag,
+      const dealii::types::blas_int *n,
+      const double *                 a,
+      const dealii::types::blas_int *lda,
+      double *                       rcond,
+      double *                       work,
+      dealii::types::blas_int *      iwork,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("dgelsd"));
+#ifdef DEAL_II_WITH_LAPACK
+  dtrcon_(norm, uplo, diag, n, a, lda, rcond, work, iwork, info);
+#else
+  (void)norm;
+  (void)uplo;
+  (void)diag;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)rcond;
+  (void)work;
+  (void)iwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dtrcon"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-gelsd(const types::blas_int *m,
-      const types::blas_int *n,
-      const types::blas_int *nrhs,
-      const float *          A,
-      const types::blas_int *lda,
-      float *                B,
-      const types::blas_int *ldb,
-      float *                s,
-      const float *          rcond,
-      types::blas_int *      rank,
-      float *                work,
-      const types::blas_int *lwork,
-      types::blas_int *      iwork,
-      types::blas_int *      info)
+trcon(const char *                   norm,
+      const char *                   uplo,
+      const char *                   diag,
+      const dealii::types::blas_int *n,
+      const std::complex<float> *    a,
+      const dealii::types::blas_int *lda,
+      float *                        rcond,
+      std::complex<float> *          work,
+      float *                        rwork,
+      dealii::types::blas_int *      info)
 {
-  sgelsd_(m, n, nrhs, A, lda, B, ldb, s, rcond, rank, work, lwork, iwork, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  ctrcon_(norm, uplo, diag, n, a, lda, rcond, work, rwork, info);
 #else
+  (void)norm;
+  (void)uplo;
+  (void)diag;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)rcond;
+  (void)work;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ctrcon"));
+#endif // DEAL_II_WITH_LAPACK
+}
+
+
+
 inline void
-gelsd(const types::blas_int *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      float *,
-      const float *,
-      types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *,
-      types::blas_int *)
+trcon(const char *                   norm,
+      const char *                   uplo,
+      const char *                   diag,
+      const dealii::types::blas_int *n,
+      const std::complex<double> *   a,
+      const dealii::types::blas_int *lda,
+      double *                       rcond,
+      std::complex<double> *         work,
+      double *                       rwork,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("sgelsd"));
+#ifdef DEAL_II_WITH_LAPACK
+  ztrcon_(norm, uplo, diag, n, a, lda, rcond, work, rwork, info);
+#else
+  (void)norm;
+  (void)uplo;
+  (void)diag;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)rcond;
+  (void)work;
+  (void)rwork;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ztrcon"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dstev and sstev
-template <typename number1,
-          typename number2,
-          typename number3,
-          typename number4>
+
+template <typename number1, typename number2>
 inline void
-stev(const char *,
-     const types::blas_int *,
-     number1 *,
+trmv(const char *,
+     const char *,
+     const char *,
+     const dealii::types::blas_int *,
+     const number1 *,
+     const dealii::types::blas_int *,
      number2 *,
-     number3 *,
-     const types::blas_int *,
-     number4 *,
-     types::blas_int *)
+     const dealii::types::blas_int *)
 {
   Assert(false, ExcNotImplemented());
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-stev(const char *           jobz,
-     const types::blas_int *n,
-     double *               d,
-     double *               e,
-     double *               z,
-     const types::blas_int *ldz,
-     double *               work,
-     types::blas_int *      info)
+trmv(const char *                   uplo,
+     const char *                   trans,
+     const char *                   diag,
+     const dealii::types::blas_int *n,
+     const float *                  a,
+     const dealii::types::blas_int *lda,
+     float *                        x,
+     const dealii::types::blas_int *incx)
 {
-  dstev_(jobz, n, d, e, z, ldz, work, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  strmv_(uplo, trans, diag, n, a, lda, x, incx);
 #else
-inline void
-stev(const char *,
-     const types::blas_int *,
-     double *,
-     double *,
-     double *,
-     const types::blas_int *,
-     double *,
-     types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dstev"));
+  (void)uplo;
+  (void)trans;
+  (void)diag;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)x;
+  (void)incx;
+  Assert(false, LAPACKSupport::ExcMissing("strmv"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-#ifdef DEAL_II_WITH_LAPACK
+
 inline void
-stev(const char *           jobz,
-     const types::blas_int *n,
-     float *                d,
-     float *                e,
-     float *                z,
-     const types::blas_int *ldz,
-     float *                work,
-     types::blas_int *      info)
+trmv(const char *                   uplo,
+     const char *                   trans,
+     const char *                   diag,
+     const dealii::types::blas_int *n,
+     const double *                 a,
+     const dealii::types::blas_int *lda,
+     double *                       x,
+     const dealii::types::blas_int *incx)
 {
-  sstev_(jobz, n, d, e, z, ldz, work, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  dtrmv_(uplo, trans, diag, n, a, lda, x, incx);
 #else
-inline void
-stev(const char *,
-     const types::blas_int *,
-     float *,
-     float *,
-     float *,
-     const types::blas_int *,
-     float *,
-     types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("sstev"));
+  (void)uplo;
+  (void)trans;
+  (void)diag;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)x;
+  (void)incx;
+  Assert(false, LAPACKSupport::ExcMissing("dtrmv"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dlascl and slascl
-template <typename number>
+
 inline void
-lascl(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const number *,
-      const number *,
-      const types::blas_int *,
-      const types::blas_int *,
-      number *,
-      const types::blas_int *,
-      types::blas_int *)
+trmv(const char *                   uplo,
+     const char *                   trans,
+     const char *                   diag,
+     const dealii::types::blas_int *n,
+     const std::complex<float> *    a,
+     const dealii::types::blas_int *lda,
+     std::complex<float> *          x,
+     const dealii::types::blas_int *incx)
 {
-  Assert(false, ExcNotImplemented());
+#ifdef DEAL_II_WITH_LAPACK
+  ctrmv_(uplo, trans, diag, n, a, lda, x, incx);
+#else
+  (void)uplo;
+  (void)trans;
+  (void)diag;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)x;
+  (void)incx;
+  Assert(false, LAPACKSupport::ExcMissing("ctrmv"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-lascl(const char *           type,
-      const types::blas_int *kl,
-      const types::blas_int *ku,
-      const double *         cfrom,
-      const double *         cto,
-      const types::blas_int *m,
-      const types::blas_int *n,
-      double *               A,
-      const types::blas_int *lda,
-      types::blas_int *      info)
+trmv(const char *                   uplo,
+     const char *                   trans,
+     const char *                   diag,
+     const dealii::types::blas_int *n,
+     const std::complex<double> *   a,
+     const dealii::types::blas_int *lda,
+     std::complex<double> *         x,
+     const dealii::types::blas_int *incx)
 {
-  dlascl_(type, kl, ku, cfrom, cto, m, n, A, lda, info);
-}
+#ifdef DEAL_II_WITH_LAPACK
+  ztrmv_(uplo, trans, diag, n, a, lda, x, incx);
 #else
-inline void
-lascl(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const double *,
-      const double *,
-      const types::blas_int *,
-      const types::blas_int *,
-      double *,
-      const types::blas_int *,
-      types::blas_int *)
-{
-  Assert(false, LAPACKSupport::ExcMissing("dlascl"));
+  (void)uplo;
+  (void)trans;
+  (void)diag;
+  (void)n;
+  (void)a;
+  (void)lda;
+  (void)x;
+  (void)incx;
+  Assert(false, LAPACKSupport::ExcMissing("ztrmv"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
+template <typename number1, typename number2>
 inline void
-lascl(const char *           type,
-      const types::blas_int *kl,
-      const types::blas_int *ku,
-      const float *          cfrom,
-      const float *          cto,
-      const types::blas_int *m,
-      const types::blas_int *n,
-      float *                A,
-      const types::blas_int *lda,
-      types::blas_int *      info)
+trtrs(const char *,
+      const char *,
+      const char *,
+      const dealii::types::blas_int *,
+      const dealii::types::blas_int *,
+      const number1 *,
+      const dealii::types::blas_int *,
+      number2 *,
+      const dealii::types::blas_int *,
+      dealii::types::blas_int *)
 {
-  slascl_(type, kl, ku, cfrom, cto, m, n, A, lda, info);
+  Assert(false, ExcNotImplemented());
 }
-#else
+
+
+
 inline void
-lascl(const char *,
-      const types::blas_int *,
-      const types::blas_int *,
-      const float *,
-      const float *,
-      const types::blas_int *,
-      const types::blas_int *,
-      float *,
-      const types::blas_int *,
-      types::blas_int *)
+trtrs(const char *                   uplo,
+      const char *                   trans,
+      const char *                   diag,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const float *                  a,
+      const dealii::types::blas_int *lda,
+      float *                        b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, LAPACKSupport::ExcMissing("slascl"));
+#ifdef DEAL_II_WITH_LAPACK
+  strtrs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info);
+#else
+  (void)uplo;
+  (void)trans;
+  (void)diag;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("strtrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
 
 
-/// Template wrapper for LAPACK functions dlamch and slamch
-template <typename number>
+
 inline void
-lamch(const char * /*chmach*/, number & /*precision*/)
+trtrs(const char *                   uplo,
+      const char *                   trans,
+      const char *                   diag,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const double *                 a,
+      const dealii::types::blas_int *lda,
+      double *                       b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  Assert(false, ExcNotImplemented());
+#ifdef DEAL_II_WITH_LAPACK
+  dtrtrs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info);
+#else
+  (void)uplo;
+  (void)trans;
+  (void)diag;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("dtrtrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
-#ifdef DEAL_II_WITH_LAPACK
+
+
 inline void
-lamch(const char *chmach, double &precision)
+trtrs(const char *                   uplo,
+      const char *                   trans,
+      const char *                   diag,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const std::complex<float> *    a,
+      const dealii::types::blas_int *lda,
+      std::complex<float> *          b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  precision = dlamch_(chmach);
+#ifdef DEAL_II_WITH_LAPACK
+  ctrtrs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info);
+#else
+  (void)uplo;
+  (void)trans;
+  (void)diag;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ctrtrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
 
+
+
 inline void
-lamch(const char *chmach, float &precision)
+trtrs(const char *                   uplo,
+      const char *                   trans,
+      const char *                   diag,
+      const dealii::types::blas_int *n,
+      const dealii::types::blas_int *nrhs,
+      const std::complex<double> *   a,
+      const dealii::types::blas_int *lda,
+      std::complex<double> *         b,
+      const dealii::types::blas_int *ldb,
+      dealii::types::blas_int *      info)
 {
-  precision = slamch_(chmach);
+#ifdef DEAL_II_WITH_LAPACK
+  ztrtrs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info);
+#else
+  (void)uplo;
+  (void)trans;
+  (void)diag;
+  (void)n;
+  (void)nrhs;
+  (void)a;
+  (void)lda;
+  (void)b;
+  (void)ldb;
+  (void)info;
+  Assert(false, LAPACKSupport::ExcMissing("ztrtrs"));
+#endif // DEAL_II_WITH_LAPACK
 }
-#endif
-
 DEAL_II_NAMESPACE_CLOSE
 
 #endif
index 71264b6dfb42217985c9d977c5069e9d3c4d1f71..dea62ebbaf4a780c90743783f1c3868b5a3e9a56 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-for (S : REAL_AND_COMPLEX_SCALARS)
+for (S : REAL_SCALARS)
   {
     template class LAPACKFullMatrix<S>;
     template class PreconditionLU<S>;

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.