From 01934e998d3b8d5ec34459415df6f892f80112c8 Mon Sep 17 00:00:00 2001 From: David Wells Date: Tue, 29 May 2018 10:39:17 -0400 Subject: [PATCH] Add a script that generates lapack_templates.h. 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 | 650 ++ .../lapack_templates_data/blas_subroutines | 6 + .../lapack_templates_data/fp_subroutines | 1 + .../lapack_templates_data/lapack_subroutines | 27 + include/deal.II/lac/lapack_templates.h | 7779 +++++++++++------ source/lac/lapack_full_matrix.inst.in | 2 +- 6 files changed, 5629 insertions(+), 2836 deletions(-) create mode 100755 contrib/utilities/generate_lapack_templates create mode 100644 contrib/utilities/lapack_templates_data/blas_subroutines create mode 100644 contrib/utilities/lapack_templates_data/fp_subroutines create mode 100644 contrib/utilities/lapack_templates_data/lapack_subroutines diff --git a/contrib/utilities/generate_lapack_templates b/contrib/utilities/generate_lapack_templates new file mode 100755 index 0000000000..5ad6d73dc8 --- /dev/null +++ b/contrib/utilities/generate_lapack_templates @@ -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' + if regex == 'COMPLEX*16': + return 'std::complex' + 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' + if regex.pattern == 'COMPLEX\\*16': + return 'std::complex' + + 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' + if string == 'z': + return 'std::complex' + 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 ", file=output) + print("", file=output) + print("#include ", file=output) + print("", file=output) + print("#ifdef DEAL_II_HAVE_FP_EXCEPTIONS", file=output) + print("# include ", 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 index 0000000000..e29c900e7a --- /dev/null +++ b/contrib/utilities/lapack_templates_data/blas_subroutines @@ -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 index 0000000000..3a506dd5a3 --- /dev/null +++ b/contrib/utilities/lapack_templates_data/fp_subroutines @@ -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 index 0000000000..38ad89e66c --- /dev/null +++ b/contrib/utilities/lapack_templates_data/lapack_subroutines @@ -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 diff --git a/include/deal.II/lac/lapack_templates.h b/include/deal.II/lac/lapack_templates.h index 43fc073487..f29205370b 100644 --- a/include/deal.II/lac/lapack_templates.h +++ b/include/deal.II/lac/lapack_templates.h @@ -27,788 +27,744 @@ 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 * ca, + const std::complex * cx, const dealii::types::blas_int *incx, - const double * b, - double * y, + std::complex * 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 * za, + const std::complex * zx, const dealii::types::blas_int *incx, - const float * b, - float * y, + std::complex * 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 * a, const dealii::types::blas_int *lda, - const double * beta, - double * C, - const dealii::types::blas_int *ldc); + std::complex * w, + std::complex * vl, + const dealii::types::blas_int *ldvl, + std::complex * vr, + const dealii::types::blas_int *ldvr, + std::complex * 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 * 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 * w, + std::complex * vl, + const dealii::types::blas_int *ldvl, + std::complex * vr, + const dealii::types::blas_int *ldvr, + std::complex * 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 * a, const dealii::types::blas_int *lda, + std::complex * w, + std::complex * vl, + const dealii::types::blas_int *ldvl, + std::complex * 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 * 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 * a, const dealii::types::blas_int *lda, + std::complex * w, + std::complex * vl, + const dealii::types::blas_int *ldvl, + std::complex * 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 * 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 * a, const dealii::types::blas_int *lda, - double * rcond, - double * work, + std::complex * b, + const dealii::types::blas_int *ldb, + float * s, + const float * rcond, + dealii::types::blas_int * rank, + std::complex * 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 * a, const dealii::types::blas_int *lda, - float * rcond, - float * work, + std::complex * b, + const dealii::types::blas_int *ldb, + double * s, + const double * rcond, + dealii::types::blas_int * rank, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * b, + const dealii::types::blas_int *ldb, + const std::complex * beta, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * b, + const dealii::types::blas_int *ldb, + const std::complex * beta, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * x, + const dealii::types::blas_int *incx, + const std::complex * beta, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * x, + const dealii::types::blas_int *incx, + const std::complex * beta, + std::complex * 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 * a, const dealii::types::blas_int *lda, - float * work); - double - dlange_(const char * norm, - const dealii::types::blas_int *m, + std::complex * tau, + std::complex * 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 * a, const dealii::types::blas_int *lda, - double * work); - float - slange_(const char * norm, + std::complex * tau, + std::complex * 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 * a, const dealii::types::blas_int *lda, - float * tau, - float * work, + float * s, + std::complex * u, + const dealii::types::blas_int *ldu, + std::complex * vt, + const dealii::types::blas_int *ldvt, + std::complex * 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 * a, const dealii::types::blas_int *lda, - const double * tau, - double * B, - const dealii::types::blas_int *ldb, - double * work, + double * s, + std::complex * u, + const dealii::types::blas_int *ldu, + std::complex * vt, + const dealii::types::blas_int *ldvt, + std::complex * 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 * a, const dealii::types::blas_int *lda, - const float * tau, - float * work, + float * s, + std::complex * u, + const dealii::types::blas_int *ldu, + std::complex * vt, + const dealii::types::blas_int *ldvt, + std::complex * 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 * a, const dealii::types::blas_int *lda, - double * B, - const dealii::types::blas_int *ldb, + double * s, + std::complex * u, + const dealii::types::blas_int *ldu, + std::complex * vt, + const dealii::types::blas_int *ldvt, + std::complex * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * 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 * a, + const dealii::types::blas_int *lda, + const float * anorm, + float * rcond, + std::complex * work, + float * rwork, + dealii::types::blas_int * info); + + void + zpocon_(const char * uplo, + const dealii::types::blas_int *n, + const std::complex * a, + const dealii::types::blas_int *lda, + const double * anorm, + double * rcond, + std::complex * 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 * 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 * 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 * 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 * 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * beta, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * beta, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + float * rcond, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + double * rcond, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * b, + const dealii::types::blas_int *ldb, + dealii::types::blas_int * info); +} + +DEAL_II_NAMESPACE_OPEN + + + +template +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 * ca, + const std::complex * cx, + const dealii::types::blas_int *incx, + std::complex * 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 * za, + const std::complex * zx, + const dealii::types::blas_int *incx, + std::complex * 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 +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 * a, + const dealii::types::blas_int *lda, + std::complex * w, + std::complex * vl, + const dealii::types::blas_int *ldvl, + std::complex * vr, + const dealii::types::blas_int *ldvr, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * w, + std::complex * vl, + const dealii::types::blas_int *ldvl, + std::complex * vr, + const dealii::types::blas_int *ldvr, + std::complex * 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 +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 * a, + const dealii::types::blas_int *lda, + std::complex * w, + std::complex * vl, + const dealii::types::blas_int *ldvl, + std::complex * 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 * 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 * a, + const dealii::types::blas_int *lda, + std::complex * w, + std::complex * vl, + const dealii::types::blas_int *ldvl, + std::complex * 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 * 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 +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 * a, + const dealii::types::blas_int *lda, + std::complex * b, + const dealii::types::blas_int *ldb, + float * s, + const float * rcond, + dealii::types::blas_int * rank, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * b, + const dealii::types::blas_int *ldb, + double * s, + const double * rcond, + dealii::types::blas_int * rank, + std::complex * 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 +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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * b, + const dealii::types::blas_int *ldb, + const std::complex * beta, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * b, + const dealii::types::blas_int *ldb, + const std::complex * beta, + std::complex * 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 +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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * x, + const dealii::types::blas_int *incx, + const std::complex * beta, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * x, + const dealii::types::blas_int *incx, + const std::complex * beta, + std::complex * 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 +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 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 * a, + const dealii::types::blas_int *lda, + std::complex * tau, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * tau, + std::complex * 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 +template 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 * a, + const dealii::types::blas_int *lda, + float * s, + std::complex * u, + const dealii::types::blas_int *ldu, + std::complex * vt, + const dealii::types::blas_int *ldvt, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + double * s, + std::complex * u, + const dealii::types::blas_int *ldu, + std::complex * vt, + const dealii::types::blas_int *ldvt, + std::complex * 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 +template 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 * a, + const dealii::types::blas_int *lda, + float * s, + std::complex * u, + const dealii::types::blas_int *ldu, + std::complex * vt, + const dealii::types::blas_int *ldvt, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + double * s, + std::complex * u, + const dealii::types::blas_int *ldu, + std::complex * vt, + const dealii::types::blas_int *ldvt, + std::complex * 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 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 * 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 * 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 + +template 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 * a, + const dealii::types::blas_int *lda, + const dealii::types::blas_int *ipiv, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + const dealii::types::blas_int *ipiv, + std::complex * 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 +template 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 * a, + const dealii::types::blas_int *lda, + const dealii::types::blas_int *ipiv, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + const dealii::types::blas_int *ipiv, + std::complex * 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 -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 +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 -inline void -potrf(const char *, - const types::blas_int *, - number1 *, - const types::blas_int *, - types::blas_int *) +template +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 -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 * 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 * 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 +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 -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 * 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 * 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 + + +template 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 -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 * 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 * 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 -inline number -lange(const char *, - const types::blas_int *, - const types::blas_int *, - const number *, - const types::blas_int *, - number *) +template +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 + + +template 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 + +template 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 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 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 * a, + const dealii::types::blas_int *lda, + const float * anorm, + float * rcond, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + const double * anorm, + double * rcond, + std::complex * 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 + +template 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 + 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 * 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 * 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 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 + 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 * 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 * 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 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 + 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 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 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 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 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 -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 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 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 + +template 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 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * beta, + std::complex * 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 * alpha, + const std::complex * a, + const dealii::types::blas_int *lda, + const std::complex * beta, + std::complex * 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 + +template 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 * a, + const dealii::types::blas_int *lda, + float * rcond, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + double * rcond, + std::complex * 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 + +template 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 + 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 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 + 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 * a, + const dealii::types::blas_int *lda, + std::complex * 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 diff --git a/source/lac/lapack_full_matrix.inst.in b/source/lac/lapack_full_matrix.inst.in index 71264b6dfb..dea62ebbaf 100644 --- a/source/lac/lapack_full_matrix.inst.in +++ b/source/lac/lapack_full_matrix.inst.in @@ -15,7 +15,7 @@ -for (S : REAL_AND_COMPLEX_SCALARS) +for (S : REAL_SCALARS) { template class LAPACKFullMatrix; template class PreconditionLU; -- 2.39.5