diff --git a/README.md b/README.md index 3cd91f2b..f656cbf4 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ MeteoInfo: GIS and scientific computation environment for meteorological communi [![DOI](https://zenodo.org/badge/172686439.svg)](https://zenodo.org/badge/latestdoi/172686439) [![Project Map](https://sourcespy.com/shield.svg)](https://sourcespy.com/github/meteoinfometeoinfo/) -**MeteoInfo** is an intergrated framework for GIS application (**MeteoInfoMap**), scientific computation and +**MeteoInfo** is an integrated framework for GIS application (**MeteoInfoMap**), scientific computation and visualization environment (**MeteoInfoLab**), especially for meteorological community. **MeteoInfoMap** is a GIS application which enables the user to visualize and analyze @@ -18,8 +18,6 @@ ability of multiple dimensional array calculation and 2D/3D plotting. ![MeteoInfoLab GUI](images/MeteoInfoLab.PNG) -**MeteoInfoLib** is a Java library providing main functions of MeteoInfoMap and MeteoInfoLab. - It requires that Java 8 or greater be installed on your computer. See the http://www.java.com website for a free download of Java if you do not have it already installed. diff --git a/meteoinfo-lab/milconfig.xml b/meteoinfo-lab/milconfig.xml index 13d7a0d8..c27edf08 100644 --- a/meteoinfo-lab/milconfig.xml +++ b/meteoinfo-lab/milconfig.xml @@ -1,36 +1,36 @@ - - - - - - + - - - + + + + + + + + - - - + + + - - - + + + diff --git a/meteoinfo-lab/pylib/mipylib/numeric/core/_ndarray.py b/meteoinfo-lab/pylib/mipylib/numeric/core/_ndarray.py index 5992aaae..b7a38fa0 100644 --- a/meteoinfo-lab/pylib/mipylib/numeric/core/_ndarray.py +++ b/meteoinfo-lab/pylib/mipylib/numeric/core/_ndarray.py @@ -698,6 +698,16 @@ class NDArray(object): else: ArrayMath.setImage(self._array, val) + def conj(self): + """ + Return the complex conjugate, element-wise. + + The complex conjugate of a complex number is obtained by changing the sign of its imaginary part. + + :return: (*array*) Complex conjugate array. + """ + return NDArray(ArrayMath.conj(self._array)) + def min(self, axis=None): """ Get minimum value along an axis. @@ -707,8 +717,13 @@ class NDArray(object): :returns: Minimum values. """ - if isinstance(axis, (list, tuple)) and len(axis) == self.ndim: + if self.ndim == 1: axis = None + elif isinstance(axis, (list, tuple)): + if len(axis) == 1: + axis = axis[0] + elif len(axis) == self.ndim: + axis = None if axis is None: r = ArrayMath.min(self._array) @@ -768,8 +783,13 @@ class NDArray(object): :returns: Maximum values. """ - if isinstance(axis, (list, tuple)) and len(axis) == self.ndim: + if self.ndim == 1: axis = None + elif isinstance(axis, (list, tuple)): + if len(axis) == 1: + axis = axis[0] + elif len(axis) == self.ndim: + axis = None if axis is None: r = ArrayMath.max(self._array) @@ -787,12 +807,27 @@ class NDArray(object): returns: (*array_like*) Sum result """ - if isinstance(axis, (list, tuple)) and len(axis) == self.ndim: + if self.ndim == 1: axis = None + elif isinstance(axis, (list, tuple)): + if len(axis) == 1: + axis = axis[0] + elif len(axis) == self.ndim: + axis = None if axis is None: return ArrayMath.sum(self._array) else: + if isinstance(axis, (list, tuple)): + aa = [] + for a in axis: + if a < 0: + a = self.ndim + a + aa.append(a) + axis = aa + else: + if axis < 0: + axis = self.ndim + axis r = ArrayMath.sum(self._array, axis) return NDArray(r) diff --git a/meteoinfo-lab/pylib/mipylib/numeric/core/fromnumeric$py.class b/meteoinfo-lab/pylib/mipylib/numeric/core/fromnumeric$py.class index 078a2375..c6222f24 100644 Binary files a/meteoinfo-lab/pylib/mipylib/numeric/core/fromnumeric$py.class and b/meteoinfo-lab/pylib/mipylib/numeric/core/fromnumeric$py.class differ diff --git a/meteoinfo-lab/pylib/mipylib/numeric/core/fromnumeric.py b/meteoinfo-lab/pylib/mipylib/numeric/core/fromnumeric.py index d4c9b06f..35572adf 100644 --- a/meteoinfo-lab/pylib/mipylib/numeric/core/fromnumeric.py +++ b/meteoinfo-lab/pylib/mipylib/numeric/core/fromnumeric.py @@ -138,15 +138,15 @@ def sum(x, axis=None): r = ArrayMath.sum(x.asarray()) return r else: - r = ArrayMath.sum(x.asarray(), axis) - if type(x) is NDArray: - return NDArray(r) - else: + r = x.sum(axis) + if isinstance(x, DimArray): dims = [] for i in range(0, x.ndim): if i != axis: dims.append(x.dims[i]) - return DimArray(NDArray(r), dims, x.fill_value, x.proj) + return DimArray(r, dims, x.fill_value, x.proj) + else: + return r def prod(x, axis=None): diff --git a/meteoinfo-lab/pylib/mipylib/numeric/core/numeric$py.class b/meteoinfo-lab/pylib/mipylib/numeric/core/numeric$py.class index 2206520e..86f678c0 100644 Binary files a/meteoinfo-lab/pylib/mipylib/numeric/core/numeric$py.class and b/meteoinfo-lab/pylib/mipylib/numeric/core/numeric$py.class differ diff --git a/meteoinfo-lab/pylib/mipylib/numeric/core/numeric.py b/meteoinfo-lab/pylib/mipylib/numeric/core/numeric.py index 98b3ad4d..51f1e002 100644 --- a/meteoinfo-lab/pylib/mipylib/numeric/core/numeric.py +++ b/meteoinfo-lab/pylib/mipylib/numeric/core/numeric.py @@ -37,7 +37,7 @@ newaxis = None __all__ = [ 'pi','e','inf','nan','acos','abs','all','allclose','any','arange','arange1', - 'argmin','argmax','argsort','array','array_split','asanyarray','asarray','asgridarray', + 'argmin','argmax','argsort','array','array_split','amax','amin','asanyarray','asarray','asgridarray', 'asgriddata','arcsin','asin','asmiarray','asstationdata','atleast_1d','atleast_2d','arctan','atan', 'arctan2','atan2','ave_month','average','histogram','broadcast_to','cdiff','ceil', 'concatenate','conj','conjugate','corrcoef','cos','cosh','cylinder','degrees','delete','delnan','diag','diff', @@ -1525,6 +1525,19 @@ def min(a, axis=None): if isinstance(a, (list, tuple)): a = array(a) return a.min(axis) + +def amin(a, axis=None): + """ + Return the minimum of an array or minimum along an axis. + + `amin` is an alias of `~numeric.min`. + + See Also + -------- + min : alias of this function + NDArray.min : equivalent method + """ + return min(a, axis) def max(a, axis=None): """ @@ -1540,6 +1553,19 @@ def max(a, axis=None): if isinstance(a, (list, tuple)): a = array(a) return a.max(axis) + +def amax(a, axis=None): + """ + Return the maximum of an array or maximum along an axis. + + `amax` is an alias of `~numeric.max`. + + See Also + -------- + max : alias of this function + NDArray.max : equivalent method + """ + return max(a, axis) def argmin(a, axis=None): """ diff --git a/meteoinfo-lab/pylib/mipylib/numeric/linalg/linalg$py.class b/meteoinfo-lab/pylib/mipylib/numeric/linalg/linalg$py.class index 4090feb2..39651995 100644 Binary files a/meteoinfo-lab/pylib/mipylib/numeric/linalg/linalg$py.class and b/meteoinfo-lab/pylib/mipylib/numeric/linalg/linalg$py.class differ diff --git a/meteoinfo-lab/pylib/mipylib/numeric/linalg/linalg.py b/meteoinfo-lab/pylib/mipylib/numeric/linalg/linalg.py index b1f014ad..19f245e8 100644 --- a/meteoinfo-lab/pylib/mipylib/numeric/linalg/linalg.py +++ b/meteoinfo-lab/pylib/mipylib/numeric/linalg/linalg.py @@ -12,7 +12,7 @@ from org.meteoinfo.math.stats import StatsUtil from .. import core as np -__all__ = ['solve', 'cholesky', 'det', 'lu', 'qr', 'svd', 'eig', 'inv', 'lstsq', 'slogdet', +__all__ = ['solve', 'cholesky', 'cond', 'det', 'lu', 'qr', 'svd', 'eig', 'inv', 'lstsq', 'slogdet', 'solve_triangular', 'norm', 'pinv'] @@ -177,7 +177,7 @@ def qr(a): return q, r -def svd(a, full_matrices=True): +def svd(a, full_matrices=True, compute_uv=True): """ Singular Value Decomposition. @@ -193,9 +193,13 @@ def svd(a, full_matrices=True): full_matrices: bool, optional If True (default), u and vh have the shapes (..., M, M) and (..., N, N), respectively. Otherwise, the shapes are (..., M, K) and (..., K, N), respectively, where K = min(M, N). + compute_uv:bool, optional + Whether to compute u and vh in addition to s. True by default. Returns ------- + When `compute_uv` is True, the result is a namedtuple with the following attribute names: + U : ndarray Unitary matrix having left singular vectors as columns. Of shape ``(M,K)``. @@ -208,10 +212,13 @@ def svd(a, full_matrices=True): """ r = LinalgUtil.svd(a.asarray(), full_matrices) # r = LinalgUtil.svd_EJML(a.asarray()) - U = np.NDArray(r[0]) s = np.NDArray(r[1]) - Vh = np.NDArray(r[2]) - return U, s, Vh + if compute_uv: + U = np.NDArray(r[0]) + Vh = np.NDArray(r[2]) + return U, s, Vh + else: + return s def eig(a): @@ -326,6 +333,34 @@ def slogdet(a): return r[0], r[1] +def _multi_svd_norm(x, row_axis, col_axis, op): + """Compute a function of the singular values of the 2-D matrices in `x`. + + This is a private utility function used by `numpy.linalg.norm()`. + + Parameters + ---------- + x : ndarray + row_axis, col_axis : int + The axes of `x` that hold the 2-D matrices. + op : callable + This should be either amin or `amax` or `sum`. + + Returns + ------- + result : float or ndarray + If `x` is 2-D, the return values is a float. + Otherwise, it is an array with ``x.ndim - 2`` dimensions. + The return values are either the minimum or maximum or sum of the + singular values of the matrices, depending on whether `op` + is `amin` or `amax` or `sum`. + + """ + y = np.moveaxis(x, (row_axis, col_axis), (-2, -1)) + result = op(svd(y, compute_uv=False), axis=-1) + return result + + def norm(x, ord=None, axis=None, keepdims=False): """ Matrix or vector norm. @@ -407,50 +442,144 @@ def norm(x, ord=None, axis=None, keepdims=False): # None of the str-type keywords for ord ('fro', 'nuc') # are valid for vectors elif isinstance(ord, str): - raise ValueError("Invalid norm order '{ord}' for vectors".format(ord)) + raise ValueError("Invalid norm order {} for vectors".format(ord)) else: absx = np.abs(x) absx **= ord ret = absx.sum(axis=axis) - ret **= np.reciprocal(ord) + ret **= (1. / ord) return ret - # elif len(axis) == 2: - # row_axis, col_axis = axis - # row_axis = np.normalize_axis_index(row_axis, nd) - # col_axis = np.normalize_axis_index(col_axis, nd) - # if row_axis == col_axis: - # raise ValueError('Duplicate axes given.') - # if ord == 2: - # ret = _multi_svd_norm(x, row_axis, col_axis, amax) - # elif ord == -2: - # ret = _multi_svd_norm(x, row_axis, col_axis, amin) - # elif ord == 1: - # if col_axis > row_axis: - # col_axis -= 1 - # ret = add.reduce(np.abs(x), axis=row_axis).max(axis=col_axis) - # elif ord == np.inf: - # if row_axis > col_axis: - # row_axis -= 1 - # ret = add.reduce(np.abs(x), axis=col_axis).max(axis=row_axis) - # elif ord == -1: - # if col_axis > row_axis: - # col_axis -= 1 - # ret = add.reduce(np.abs(x), axis=row_axis).min(axis=col_axis) - # elif ord == -np.inf: - # if row_axis > col_axis: - # row_axis -= 1 - # ret = add.reduce(np.abs(x), axis=col_axis).min(axis=row_axis) - # elif ord in [None, 'fro', 'f']: - # ret = np.sqrt(add.reduce((x.conj() * x).real, axis=axis)) - # elif ord == 'nuc': - # ret = _multi_svd_norm(x, row_axis, col_axis, sum) - # else: - # raise ValueError("Invalid norm order for matrices.") - # if keepdims: - # ret_shape = list(x.shape) - # ret_shape[axis[0]] = 1 - # ret_shape[axis[1]] = 1 - # ret = ret.reshape(ret_shape) - # return ret - # else: - # raise ValueError("Improper number of dimensions to norm.") + elif len(axis) == 2: + row_axis, col_axis = axis + row_axis = np.normalize_axis_index(row_axis, nd) + col_axis = np.normalize_axis_index(col_axis, nd) + if row_axis == col_axis: + raise ValueError('Duplicate axes given.') + if ord == 2: + ret = _multi_svd_norm(x, row_axis, col_axis, np.amax) + elif ord == -2: + ret = _multi_svd_norm(x, row_axis, col_axis, np.amin) + elif ord == 1: + if col_axis > row_axis: + col_axis -= 1 + ret = np.sum(np.abs(x), axis=row_axis).max(axis=col_axis) + elif ord == np.inf: + if row_axis > col_axis: + row_axis -= 1 + ret = np.sum(np.abs(x), axis=col_axis).max(axis=row_axis) + elif ord == -1: + if col_axis > row_axis: + col_axis -= 1 + ret = np.sum(np.abs(x), axis=row_axis).min(axis=col_axis) + elif ord == -np.inf: + if row_axis > col_axis: + row_axis -= 1 + ret = np.sum(np.abs(x), axis=col_axis).min(axis=row_axis) + elif ord in [None, 'fro', 'f']: + ret = np.sqrt(np.sum((x.conj() * x).real, axis=axis)) + elif ord == 'nuc': + ret = _multi_svd_norm(x, row_axis, col_axis, np.sum) + else: + raise ValueError("Invalid norm order for matrices.") + if keepdims: + ret_shape = list(x.shape) + ret_shape[axis[0]] = 1 + ret_shape[axis[1]] = 1 + ret = ret.reshape(ret_shape) + return ret + else: + raise ValueError("Improper number of dimensions to norm.") + + +def cond(x, p=None): + """ + Compute the condition number of a matrix. + + This function is capable of returning the condition number using + one of seven different norms, depending on the value of `p` (see + Parameters below). + + Parameters + ---------- + x : (..., M, N) array_like + The matrix whose condition number is sought. + p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}, optional + Order of the norm used in the condition number computation: + + ===== ============================ + p norm for matrices + ===== ============================ + None 2-norm, computed directly using the ``SVD`` + 'fro' Frobenius norm + inf max(sum(abs(x), axis=1)) + -inf min(sum(abs(x), axis=1)) + 1 max(sum(abs(x), axis=0)) + -1 min(sum(abs(x), axis=0)) + 2 2-norm (largest sing. value) + -2 smallest singular value + ===== ============================ + + inf means the `numpy.inf` object, and the Frobenius norm is + the root-of-sum-of-squares norm. + + Returns + ------- + c : {float, inf} + The condition number of the matrix. May be infinite. + + See Also + -------- + numpy.linalg.norm + + Notes + ----- + The condition number of `x` is defined as the norm of `x` times the + norm of the inverse of `x` [1]_; the norm can be the usual L2-norm + (root-of-sum-of-squares) or one of a number of other matrix norms. + + References + ---------- + .. [1] G. Strang, *Linear Algebra and Its Applications*, Orlando, FL, + Academic Press, Inc., 1980, pg. 285. + + Examples + -------- + >>> from mipylib.numeric import linalg as LA + >>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]]) + >>> a + array([[ 1, 0, -1], + [ 0, 1, 0], + [ 1, 0, 1]]) + >>> LA.cond(a) + 1.4142135623730951 + >>> LA.cond(a, 'fro') + 3.1622776601683795 + >>> LA.cond(a, np.inf) + 2.0 + >>> LA.cond(a, -np.inf) + 1.0 + >>> LA.cond(a, 1) + 2.0 + >>> LA.cond(a, -1) + 1.0 + >>> LA.cond(a, 2) + 1.4142135623730951 + >>> LA.cond(a, -2) + 0.70710678118654746 # may vary + >>> min(LA.svd(a, compute_uv=False))*min(LA.svd(LA.inv(a), compute_uv=False)) + 0.70710678118654746 # may vary + """ + x = np.asarray(x) # in case we have a matrix + if p is None or p == 2 or p == -2: + s = svd(x, compute_uv=False) + if p == -2: + r = s[..., -1] / s[..., 0] + else: + r = s[..., 0] / s[..., -1] + else: + # Call inv(x) ignoring errors. The result array will + # contain nans in the entries where inversion failed. + invx = inv(x) + r = norm(x, p, axis=(-2, -1)) * norm(invx, p, axis=(-2, -1)) + + return r \ No newline at end of file diff --git a/meteoinfo-lab/pylib/mipylib/plotlib/_axes3dgl$py.class b/meteoinfo-lab/pylib/mipylib/plotlib/_axes3dgl$py.class index ffc2eb52..c81e4d1a 100644 Binary files a/meteoinfo-lab/pylib/mipylib/plotlib/_axes3dgl$py.class and b/meteoinfo-lab/pylib/mipylib/plotlib/_axes3dgl$py.class differ diff --git a/meteoinfo-lab/pylib/mipylib/plotlib/_axes3dgl.py b/meteoinfo-lab/pylib/mipylib/plotlib/_axes3dgl.py index 0014c78d..cf7c7f67 100644 --- a/meteoinfo-lab/pylib/mipylib/plotlib/_axes3dgl.py +++ b/meteoinfo-lab/pylib/mipylib/plotlib/_axes3dgl.py @@ -1501,16 +1501,19 @@ class Axes3DGL(Axes3D): def isosurface(self, *args, **kwargs): """ - creates a three-dimensional isosurface plot + creates a three-dimensional isosurface plot. :param x: (*array_like*) Optional. X coordinate array. :param y: (*array_like*) Optional. Y coordinate array. :param z: (*array_like*) Optional. Z coordinate array. - :param data: (*array_like*) 3D data array. - :param cmap: (*string*) Color map string. - :param nthread: (*int*) Thread number. Default is 4. + :param data: (*array_like*) Volume data array. + :param isovalue: (*float*) Specified isosurface value. + :param cdata: (*array_like*) Optional. Volume color data array. + :param facecolor: (*color*) Optional. Color map string. + :param cmap: (*string*) Optional. Color map string. + :param nthread: (*int*) Optional. Thread number. Default is 4. - :returns: 3D Mesh graphic + :returns: 3D Mesh graphic. """ if len(args) <= 3: x = args[0].dimvalue(2) diff --git a/meteoinfo-math/pom.xml b/meteoinfo-math/pom.xml index 86624e23..4ba9e124 100644 --- a/meteoinfo-math/pom.xml +++ b/meteoinfo-math/pom.xml @@ -53,6 +53,16 @@ openblas-platform 0.3.10-1.5.4 + + org.bytedeco + mkl-platform + 2020.3-1.5.4 + + + org.bytedeco + mkl-platform-redist + 2020.3-1.5.4 + org.junit.jupiter junit-jupiter diff --git a/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/BLAS.java b/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/BLAS.java index 18c5bfb4..0040b846 100644 --- a/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/BLAS.java +++ b/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/BLAS.java @@ -53,8 +53,8 @@ public interface BLAS { Logger logger = Logger.getLogger("BLAS.class"); try { - Class clazz = Class.forName("smile.math.blas.mkl.MKL"); - logger.info("smile-mkl module is available."); + Class clazz = Class.forName("org.meteoinfo.math.blas.mkl.MKL"); + logger.info("mkl module is available."); return (BLAS) clazz.getDeclaredConstructor().newInstance(); } catch (Exception e) { logger.info(String.format("Failed to create MKL instance: %s", e)); diff --git a/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/LAPACK.java b/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/LAPACK.java index bbcf08e5..43877ab5 100644 --- a/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/LAPACK.java +++ b/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/LAPACK.java @@ -53,8 +53,8 @@ public interface LAPACK { Logger logger = Logger.getLogger("LAPACK.class"); try { - Class clazz = Class.forName("smile.math.blas.mkl.MKL"); - logger.info("smile-mkl module is available."); + Class clazz = Class.forName("org.meteoinfo.math.blas.mkl.MKL"); + logger.info("mkl module is available."); return (LAPACK) clazz.getDeclaredConstructor().newInstance(); } catch (Exception e) { logger.info(String.format("Failed to create MKL instance: %s", e)); diff --git a/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/mkl/MKL.java b/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/mkl/MKL.java new file mode 100644 index 00000000..e3306c66 --- /dev/null +++ b/meteoinfo-math/src/main/java/org/meteoinfo/math/blas/mkl/MKL.java @@ -0,0 +1,1062 @@ +/******************************************************************************* + * Copyright (c) 2010-2020 Haifeng Li. All rights reserved. + * + * Smile is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * Smile is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Smile. If not, see . + ******************************************************************************/ + +package org.meteoinfo.math.blas.mkl; + +import java.nio.DoubleBuffer; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import org.meteoinfo.math.blas.*; +import static org.bytedeco.mkl.global.mkl_rt.*; +import static org.bytedeco.openblas.global.openblas.LAPACKE_dorgqr; +import static org.bytedeco.openblas.global.openblas.LAPACKE_dorgrq; + +/** + * Intel MKL library wrapper. + * + * @author Haifeng Li + */ +public class MKL implements BLAS, LAPACK { + @Override + public double asum(int n, double[] x, int incx) { + return cblas_dasum(n, x, incx); + } + + @Override + public float asum(int n, float[] x, int incx) { + return cblas_sasum(n, x, incx); + } + + @Override + public void axpy(int n, double alpha, double[] x, int incx, double[] y, int incy) { + cblas_daxpy(n, alpha, x, incx, y, incy); + } + + @Override + public void axpy(int n, float alpha, float[] x, int incx, float[] y, int incy) { + cblas_saxpy(n, alpha, x, incx, y, incy); + } + + @Override + public double dot(int n, double[] x, int incx, double[] y, int incy) { + return cblas_ddot(n, x, incx, y, incy); + } + + @Override + public float dot(int n, float[] x, int incx, float[] y, int incy) { + return cblas_sdot(n, x, incx, y, incy); + } + + @Override + public double nrm2(int n, double[] x, int incx) { + return cblas_dnrm2(n, x, incx); + } + + @Override + public float nrm2(int n, float[] x, int incx) { + return cblas_snrm2(n, x, incx); + } + + @Override + public void scal(int n, double alpha, double[] x, int incx) { + cblas_dscal(n, alpha, x, incx); + } + + @Override + public void scal(int n, float alpha, float[] x, int incx) { + cblas_sscal(n, alpha, x, incx); + } + + @Override + public void swap(int n, double[] x, int incx, double[] y, int incy) { + cblas_dswap(n, x, incx, y, incy); + } + + @Override + public void swap(int n, float[] x, int incx, float[] y, int incy) { + cblas_sswap(n, x, incx, y, incy); + } + + @Override + public long iamax(int n, double[] x, int incx) { + return cblas_idamax(n, x, incx); + } + + @Override + public long iamax(int n, float[] x, int incx) { + return cblas_isamax(n, x, incx); + } + + @Override + public void gemv(Layout layout, Transpose trans, int m, int n, double alpha, double[] A, int lda, double[] x, int incx, double beta, double[] y, int incy) { + cblas_dgemv(layout.blas(), trans.blas(), m, n, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void gemv(Layout layout, Transpose trans, int m, int n, double alpha, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, DoubleBuffer y, int incy) { + cblas_dgemv(layout.blas(), trans.blas(), m, n, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void gemv(Layout layout, Transpose trans, int m, int n, float alpha, float[] A, int lda, float[] x, int incx, float beta, float[] y, int incy) { + cblas_sgemv(layout.blas(), trans.blas(), m, n, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void gemv(Layout layout, Transpose trans, int m, int n, float alpha, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, FloatBuffer y, int incy) { + cblas_sgemv(layout.blas(), trans.blas(), m, n, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void symv(Layout layout, UPLO uplo, int n, double alpha, double[] A, int lda, double[] x, int incx, double beta, double[] y, int incy) { + cblas_dsymv(layout.blas(), uplo.blas(), n, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void symv(Layout layout, UPLO uplo, int n, double alpha, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, DoubleBuffer y, int incy) { + cblas_dsymv(layout.blas(), uplo.blas(), n, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void symv(Layout layout, UPLO uplo, int n, float alpha, float[] A, int lda, float[] x, int incx, float beta, float[] y, int incy) { + cblas_ssymv(layout.blas(), uplo.blas(), n, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void symv(Layout layout, UPLO uplo, int n, float alpha, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, FloatBuffer y, int incy) { + cblas_ssymv(layout.blas(), uplo.blas(), n, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void spmv(Layout layout, UPLO uplo, int n, double alpha, double[] A, double[] x, int incx, double beta, double[] y, int incy) { + cblas_dspmv(layout.blas(), uplo.blas(), n, alpha, A, x, incx, beta, y, incy); + } + + @Override + public void spmv(Layout layout, UPLO uplo, int n, double alpha, DoubleBuffer A, DoubleBuffer x, int incx, double beta, DoubleBuffer y, int incy) { + cblas_dspmv(layout.blas(), uplo.blas(), n, alpha, A, x, incx, beta, y, incy); + } + + @Override + public void spmv(Layout layout, UPLO uplo, int n, float alpha, float[] A, float[] x, int incx, float beta, float[] y, int incy) { + cblas_sspmv(layout.blas(), uplo.blas(), n, alpha, A, x, incx, beta, y, incy); + } + + @Override + public void spmv(Layout layout, UPLO uplo, int n, float alpha, FloatBuffer A, FloatBuffer x, int incx, float beta, FloatBuffer y, int incy) { + cblas_sspmv(layout.blas(), uplo.blas(), n, alpha, A, x, incx, beta, y, incy); + } + + @Override + public void trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, double[] A, int lda, double[] x, int incx) { + cblas_dtrmv(layout.blas(), uplo.blas(), trans.blas(), diag.blas(), n, A, lda, x, incx); + } + + @Override + public void trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, DoubleBuffer A, int lda, DoubleBuffer x, int incx) { + cblas_dtrmv(layout.blas(), uplo.blas(), trans.blas(), diag.blas(), n, A, lda, x, incx); + } + + @Override + public void trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, float[] A, int lda, float[] x, int incx) { + cblas_strmv(layout.blas(), uplo.blas(), trans.blas(), diag.blas(), n, A, lda, x, incx); + } + + @Override + public void trmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, FloatBuffer A, int lda, FloatBuffer x, int incx) { + cblas_strmv(layout.blas(), uplo.blas(), trans.blas(), diag.blas(), n, A, lda, x, incx); + } + + @Override + public void tpmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, double[] A, double[] x, int incx) { + cblas_dtpmv(layout.blas(), uplo.blas(), trans.blas(), diag.blas(), n, A, x, incx); + } + + @Override + public void tpmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, DoubleBuffer A, DoubleBuffer x, int incx) { + cblas_dtpmv(layout.blas(), uplo.blas(), trans.blas(), diag.blas(), n, A, x, incx); + } + + @Override + public void tpmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, float[] A, float[] x, int incx) { + cblas_stpmv(layout.blas(), uplo.blas(), trans.blas(), diag.blas(), n, A, x, incx); + } + + @Override + public void tpmv(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, FloatBuffer A, FloatBuffer x, int incx) { + cblas_stpmv(layout.blas(), uplo.blas(), trans.blas(), diag.blas(), n, A, x, incx); + } + + @Override + public void gbmv(Layout layout, Transpose trans, int m, int n, int kl, int ku, double alpha, double[] A, int lda, double[] x, int incx, double beta, double[] y, int incy) { + cblas_dgbmv(layout.blas(), trans.blas(), m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void gbmv(Layout layout, Transpose trans, int m, int n, int kl, int ku, double alpha, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, DoubleBuffer y, int incy) { + cblas_dgbmv(layout.blas(), trans.blas(), m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void gbmv(Layout layout, Transpose trans, int m, int n, int kl, int ku, float alpha, float[] A, int lda, float[] x, int incx, float beta, float[] y, int incy) { + cblas_sgbmv(layout.blas(), trans.blas(), m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void gbmv(Layout layout, Transpose trans, int m, int n, int kl, int ku, float alpha, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, FloatBuffer y, int incy) { + cblas_sgbmv(layout.blas(), trans.blas(), m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void sbmv(Layout layout, UPLO uplo, int n, int k, double alpha, double[] A, int lda, double[] x, int incx, double beta, double[] y, int incy) { + cblas_dsbmv(layout.blas(), uplo.blas(), n, k, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void sbmv(Layout layout, UPLO uplo, int n, int k, double alpha, DoubleBuffer A, int lda, DoubleBuffer x, int incx, double beta, DoubleBuffer y, int incy) { + cblas_dsbmv(layout.blas(), uplo.blas(), n, k, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void sbmv(Layout layout, UPLO uplo, int n, int k, float alpha, float[] A, int lda, float[] x, int incx, float beta, float[] y, int incy) { + cblas_ssbmv(layout.blas(), uplo.blas(), n, k, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void sbmv(Layout layout, UPLO uplo, int n, int k, float alpha, FloatBuffer A, int lda, FloatBuffer x, int incx, float beta, FloatBuffer y, int incy) { + cblas_ssbmv(layout.blas(), uplo.blas(), n, k, alpha, A, lda, x, incx, beta, y, incy); + } + + @Override + public void ger(Layout layout, int m, int n, double alpha, double[] x, int incx, double[] y, int incy, double[] A, int lda) { + cblas_dger(layout.blas(), m, n, alpha, x, incx, y, incy, A, lda); + } + + @Override + public void ger(Layout layout, int m, int n, double alpha, DoubleBuffer x, int incx, DoubleBuffer y, int incy, DoubleBuffer A, int lda) { + cblas_dger(layout.blas(), m, n, alpha, x, incx, y, incy, A, lda); + } + + @Override + public void ger(Layout layout, int m, int n, float alpha, float[] x, int incx, float[] y, int incy, float[] A, int lda) { + cblas_sger(layout.blas(), m, n, alpha, x, incx, y, incy, A, lda); + } + + @Override + public void ger(Layout layout, int m, int n, float alpha, FloatBuffer x, int incx, FloatBuffer y, int incy, FloatBuffer A, int lda) { + cblas_sger(layout.blas(), m, n, alpha, x, incx, y, incy, A, lda); + } + + @Override + public void syr(Layout layout, UPLO uplo, int n, double alpha, double[] x, int incx, double[] A, int lda) { + cblas_dsyr(layout.blas(), uplo.blas(), n, alpha, x, incx, A, lda); + } + + @Override + public void syr(Layout layout, UPLO uplo, int n, double alpha, DoubleBuffer x, int incx, DoubleBuffer A, int lda) { + cblas_dsyr(layout.blas(), uplo.blas(), n, alpha, x, incx, A, lda); + } + + @Override + public void syr(Layout layout, UPLO uplo, int n, float alpha, float[] x, int incx, float[] A, int lda) { + cblas_ssyr(layout.blas(), uplo.blas(), n, alpha, x, incx, A, lda); + } + + @Override + public void syr(Layout layout, UPLO uplo, int n, float alpha, FloatBuffer x, int incx, FloatBuffer A, int lda) { + cblas_ssyr(layout.blas(), uplo.blas(), n, alpha, x, incx, A, lda); + } + + @Override + public void spr(Layout layout, UPLO uplo, int n, double alpha, double[] x, int incx, double[] A) { + cblas_dspr(layout.blas(), uplo.blas(), n, alpha, x, incx, A); + } + + @Override + public void spr(Layout layout, UPLO uplo, int n, double alpha, DoubleBuffer x, int incx, DoubleBuffer A) { + cblas_dspr(layout.blas(), uplo.blas(), n, alpha, x, incx, A); + } + + @Override + public void spr(Layout layout, UPLO uplo, int n, float alpha, float[] x, int incx, float[] A) { + cblas_sspr(layout.blas(), uplo.blas(), n, alpha, x, incx, A); + } + + @Override + public void spr(Layout layout, UPLO uplo, int n, float alpha, FloatBuffer x, int incx, FloatBuffer A) { + cblas_sspr(layout.blas(), uplo.blas(), n, alpha, x, incx, A); + } + + @Override + public void gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc) { + cblas_dgemm(layout.blas(), transA.blas(), transB.blas(), m, n, k, alpha, A, lda, B, ldb, beta, C, ldc); + } + + @Override + public void gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, double alpha, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, DoubleBuffer C, int ldc) { + cblas_dgemm(layout.blas(), transA.blas(), transB.blas(), m, n, k, alpha, A, lda, B, ldb, beta, C, ldc); + } + + @Override + public void gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, float alpha, float[] A, int lda, float[] B, int ldb, float beta, float[] C, int ldc) { + cblas_sgemm(layout.blas(), transA.blas(), transB.blas(), m, n, k, alpha, A, lda, B, ldb, beta, C, ldc); + } + + @Override + public void gemm(Layout layout, Transpose transA, Transpose transB, int m, int n, int k, float alpha, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, FloatBuffer C, int ldc) { + cblas_sgemm(layout.blas(), transA.blas(), transB.blas(), m, n, k, alpha, A, lda, B, ldb, beta, C, ldc); + } + + @Override + public void symm(Layout layout, Side side, UPLO uplo, int m, int n, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc) { + cblas_dsymm(layout.blas(), side.blas(), uplo.blas(), m, n, alpha, A, lda, B, ldb, beta, C, ldc); + } + + @Override + public void symm(Layout layout, Side side, UPLO uplo, int m, int n, double alpha, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, double beta, DoubleBuffer C, int ldc) { + cblas_dsymm(layout.blas(), side.blas(), uplo.blas(), m, n, alpha, A, lda, B, ldb, beta, C, ldc); + } + + @Override + public void symm(Layout layout, Side side, UPLO uplo, int m, int n, float alpha, float[] A, int lda, float[] B, int ldb, float beta, float[] C, int ldc) { + cblas_ssymm(layout.blas(), side.blas(), uplo.blas(), m, n, alpha, A, lda, B, ldb, beta, C, ldc); + } + + @Override + public void symm(Layout layout, Side side, UPLO uplo, int m, int n, float alpha, FloatBuffer A, int lda, FloatBuffer B, int ldb, float beta, FloatBuffer C, int ldc) { + cblas_ssymm(layout.blas(), side.blas(), uplo.blas(), m, n, alpha, A, lda, B, ldb, beta, C, ldc); + } + + @Override + public int gesv(Layout layout, int n, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb) { + return LAPACKE_dgesv(layout.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gesv(Layout layout, int n, int nrhs, DoubleBuffer A, int lda, IntBuffer ipiv, DoubleBuffer B, int ldb) { + return LAPACKE_dgesv(layout.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gesv(Layout layout, int n, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb) { + return LAPACKE_sgesv(layout.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gesv(Layout layout, int n, int nrhs, FloatBuffer A, int lda, IntBuffer ipiv, FloatBuffer B, int ldb) { + return LAPACKE_sgesv(layout.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int sysv(Layout layout, UPLO uplo, int n, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb) { + return LAPACKE_dsysv(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int sysv(Layout layout, UPLO uplo, int n, int nrhs, DoubleBuffer A, int lda, IntBuffer ipiv, DoubleBuffer B, int ldb) { + return LAPACKE_dsysv(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int sysv(Layout layout, UPLO uplo, int n, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb) { + return LAPACKE_ssysv(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int sysv(Layout layout, UPLO uplo, int n, int nrhs, FloatBuffer A, int lda, IntBuffer ipiv, FloatBuffer B, int ldb) { + return LAPACKE_ssysv(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int spsv(Layout layout, UPLO uplo, int n, int nrhs, double[] A, int[] ipiv, double[] B, int ldb) { + return LAPACKE_dspsv(layout.lapack(), uplo.lapack(), n, nrhs, A, ipiv, B, ldb); + } + + @Override + public int spsv(Layout layout, UPLO uplo, int n, int nrhs, DoubleBuffer A, IntBuffer ipiv, DoubleBuffer B, int ldb) { + return LAPACKE_dspsv(layout.lapack(), uplo.lapack(), n, nrhs, A, ipiv, B, ldb); + } + + @Override + public int spsv(Layout layout, UPLO uplo, int n, int nrhs, float[] A, int[] ipiv, float[] B, int ldb) { + return LAPACKE_sspsv(layout.lapack(), uplo.lapack(), n, nrhs, A, ipiv, B, ldb); + } + + @Override + public int spsv(Layout layout, UPLO uplo, int n, int nrhs, FloatBuffer A, IntBuffer ipiv, FloatBuffer B, int ldb) { + return LAPACKE_sspsv(layout.lapack(), uplo.lapack(), n, nrhs, A, ipiv, B, ldb); + } + + @Override + public int posv(Layout layout, UPLO uplo, int n, int nrhs, double[] A, int lda, double[] B, int ldb) { + return LAPACKE_dposv(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int posv(Layout layout, UPLO uplo, int n, int nrhs, DoubleBuffer A, int lda, DoubleBuffer B, int ldb) { + return LAPACKE_dposv(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int posv(Layout layout, UPLO uplo, int n, int nrhs, float[] A, int lda, float[] B, int ldb) { + return LAPACKE_sposv(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int posv(Layout layout, UPLO uplo, int n, int nrhs, FloatBuffer A, int lda, FloatBuffer B, int ldb) { + return LAPACKE_sposv(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int ppsv(Layout layout, UPLO uplo, int n, int nrhs, double[] A, double[] B, int ldb) { + return LAPACKE_dppsv(layout.lapack(), uplo.lapack(), n, nrhs, A, B, ldb); + } + + @Override + public int ppsv(Layout layout, UPLO uplo, int n, int nrhs, DoubleBuffer A, DoubleBuffer B, int ldb) { + return LAPACKE_dppsv(layout.lapack(), uplo.lapack(), n, nrhs, A, B, ldb); + } + + @Override + public int ppsv(Layout layout, UPLO uplo, int n, int nrhs, float[] A, float[] B, int ldb) { + return LAPACKE_sppsv(layout.lapack(), uplo.lapack(), n, nrhs, A, B, ldb); + } + + @Override + public int ppsv(Layout layout, UPLO uplo, int n, int nrhs, FloatBuffer A, FloatBuffer B, int ldb) { + return LAPACKE_sppsv(layout.lapack(), uplo.lapack(), n, nrhs, A, B, ldb); + } + + @Override + public int gbsv(Layout layout, int n, int kl, int ku, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb) { + return LAPACKE_dgbsv(layout.lapack(), n, kl, ku, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gbsv(Layout layout, int n, int kl, int ku, int nrhs, DoubleBuffer A, int lda, IntBuffer ipiv, DoubleBuffer B, int ldb) { + return LAPACKE_dgbsv(layout.lapack(), n, kl, ku, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gbsv(Layout layout, int n, int kl, int ku, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb) { + return LAPACKE_sgbsv(layout.lapack(), n, kl, ku, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gbsv(Layout layout, int n, int kl, int ku, int nrhs, FloatBuffer A, int lda, IntBuffer ipiv, FloatBuffer B, int ldb) { + return LAPACKE_sgbsv(layout.lapack(), n, kl, ku, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gels(Layout layout, Transpose trans, int m, int n, int nrhs, double[] A, int lda, double[] B, int ldb) { + return LAPACKE_dgels(layout.lapack(), trans.lapack(), m, n, nrhs, A, lda, B, ldb); + } + + @Override + public int gels(Layout layout, Transpose trans, int m, int n, int nrhs, DoubleBuffer A, int lda, DoubleBuffer B, int ldb) { + return LAPACKE_dgels(layout.lapack(), trans.lapack(), m, n, nrhs, A, lda, B, ldb); + } + + @Override + public int gels(Layout layout, Transpose trans, int m, int n, int nrhs, float[] A, int lda, float[] B, int ldb) { + return LAPACKE_sgels(layout.lapack(), trans.lapack(), m, n, nrhs, A, lda, B, ldb); + } + + @Override + public int gels(Layout layout, Transpose trans, int m, int n, int nrhs, FloatBuffer A, int lda, FloatBuffer B, int ldb) { + return LAPACKE_sgels(layout.lapack(), trans.lapack(), m, n, nrhs, A, lda, B, ldb); + } + + @Override + public int gelsy(Layout layout, int m, int n, int nrhs, double[] A, int lda, double[] B, int ldb, int[] jpvt, double rcond, int[] rank) { + return LAPACKE_dgelsy(layout.lapack(), m, n, nrhs, A, lda, B, ldb, jpvt, rcond, rank); + } + + @Override + public int gelsy(Layout layout, int m, int n, int nrhs, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, IntBuffer jpvt, double rcond, IntBuffer rank) { + return LAPACKE_dgelsy(layout.lapack(), m, n, nrhs, A, lda, B, ldb, jpvt, rcond, rank); + } + + @Override + public int gelsy(Layout layout, int m, int n, int nrhs, float[] A, int lda, float[] B, int ldb, int[] jpvt, float rcond, int[] rank) { + return LAPACKE_sgelsy(layout.lapack(), m, n, nrhs, A, lda, B, ldb, jpvt, rcond, rank); + } + + @Override + public int gelsy(Layout layout, int m, int n, int nrhs, FloatBuffer A, int lda, FloatBuffer B, int ldb, IntBuffer jpvt, float rcond, IntBuffer rank) { + return LAPACKE_sgelsy(layout.lapack(), m, n, nrhs, A, lda, B, ldb, jpvt, rcond, rank); + } + + @Override + public int gelss(Layout layout, int m, int n, int nrhs, double[] A, int lda, double[] B, int ldb, double[] s, double rcond, int[] rank) { + return LAPACKE_dgelss(layout.lapack(), m, n, nrhs, A, lda, B, ldb, s, rcond, rank); + } + + @Override + public int gelss(Layout layout, int m, int n, int nrhs, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, DoubleBuffer s, double rcond, IntBuffer rank) { + return LAPACKE_dgelss(layout.lapack(), m, n, nrhs, A, lda, B, ldb, s, rcond, rank); + } + + @Override + public int gelss(Layout layout, int m, int n, int nrhs, float[] A, int lda, float[] B, int ldb, float[] s, float rcond, int[] rank) { + return LAPACKE_sgelss(layout.lapack(), m, n, nrhs, A, lda, B, ldb, s, rcond, rank); + } + + @Override + public int gelss(Layout layout, int m, int n, int nrhs, FloatBuffer A, int lda, FloatBuffer B, int ldb, FloatBuffer s, float rcond, IntBuffer rank) { + return LAPACKE_sgelss(layout.lapack(), m, n, nrhs, A, lda, B, ldb, s, rcond, rank); + } + + @Override + public int gelsd(Layout layout, int m, int n, int nrhs, double[] A, int lda, double[] B, int ldb, double[] s, double rcond, int[] rank) { + return LAPACKE_dgelsd(layout.lapack(), m, n, nrhs, A, lda, B, ldb, s, rcond, rank); + } + + @Override + public int gelsd(Layout layout, int m, int n, int nrhs, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, DoubleBuffer s, double rcond, IntBuffer rank) { + return LAPACKE_dgelsd(layout.lapack(), m, n, nrhs, A, lda, B, ldb, s, rcond, rank); + } + + @Override + public int gelsd(Layout layout, int m, int n, int nrhs, float[] A, int lda, float[] B, int ldb, float[] s, float rcond, int[] rank) { + return LAPACKE_sgelsd(layout.lapack(), m, n, nrhs, A, lda, B, ldb, s, rcond, rank); + } + + @Override + public int gelsd(Layout layout, int m, int n, int nrhs, FloatBuffer A, int lda, FloatBuffer B, int ldb, FloatBuffer s, float rcond, IntBuffer rank) { + return LAPACKE_sgelsd(layout.lapack(), m, n, nrhs, A, lda, B, ldb, s, rcond, rank); + } + + @Override + public int gglse(Layout layout, int m, int n, int p, double[] A, int lda, double[] B, int ldb, double[] c, double[] d, double[] x) { + return LAPACKE_dgglse(layout.lapack(), m, n, p, A, lda, B, ldb, c, d, x); + } + + @Override + public int gglse(Layout layout, int m, int n, int p, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, DoubleBuffer c, DoubleBuffer d, DoubleBuffer x) { + return LAPACKE_dgglse(layout.lapack(), m, n, p, A, lda, B, ldb, c, d, x); + } + + @Override + public int gglse(Layout layout, int m, int n, int p, float[] A, int lda, float[] B, int ldb, float[] c, float[] d, float[] x) { + return LAPACKE_sgglse(layout.lapack(), m, n, p, A, lda, B, ldb, c, d, x); + } + + @Override + public int gglse(Layout layout, int m, int n, int p, FloatBuffer A, int lda, FloatBuffer B, int ldb, FloatBuffer c, FloatBuffer d, FloatBuffer x) { + return LAPACKE_sgglse(layout.lapack(), m, n, p, A, lda, B, ldb, c, d, x); + } + + @Override + public int ggglm(Layout layout, int n, int m, int p, double[] A, int lda, double[] B, int ldb, double[] d, double[] x, double[] y) { + return LAPACKE_dggglm(layout.lapack(), n, m, p, A, lda, B, ldb, d, x, y); + } + + @Override + public int ggglm(Layout layout, int n, int m, int p, DoubleBuffer A, int lda, DoubleBuffer B, int ldb, DoubleBuffer d, DoubleBuffer x, DoubleBuffer y) { + return LAPACKE_dggglm(layout.lapack(), n, m, p, A, lda, B, ldb, d, x, y); + } + + @Override + public int ggglm(Layout layout, int n, int m, int p, float[] A, int lda, float[] B, int ldb, float[] d, float[] x, float[] y) { + return LAPACKE_sggglm(layout.lapack(), n, m, p, A, lda, B, ldb, d, x, y); + } + + @Override + public int ggglm(Layout layout, int n, int m, int p, FloatBuffer A, int lda, FloatBuffer B, int ldb, FloatBuffer d, FloatBuffer x, FloatBuffer y) { + return LAPACKE_sggglm(layout.lapack(), n, m, p, A, lda, B, ldb, d, x, y); + } + + @Override + public int geev(Layout layout, EVDJob jobvl, EVDJob jobvr, int n, double[] A, int lda, double[] wr, double[] wi, double[] Vl, int ldvl, double[] Vr, int ldvr) { + return LAPACKE_dgeev(layout.lapack(), jobvl.lapack(), jobvr.lapack(), n, A, lda, wr, wi, Vl, ldvl, Vr, ldvr); + } + + @Override + public int geev(Layout layout, EVDJob jobvl, EVDJob jobvr, int n, DoubleBuffer A, int lda, DoubleBuffer wr, DoubleBuffer wi, DoubleBuffer Vl, int ldvl, DoubleBuffer Vr, int ldvr) { + return LAPACKE_dgeev(layout.lapack(), jobvl.lapack(), jobvr.lapack(), n, A, lda, wr, wi, Vl, ldvl, Vr, ldvr); + } + + @Override + public int geev(Layout layout, EVDJob jobvl, EVDJob jobvr, int n, float[] A, int lda, float[] wr, float[] wi, float[] Vl, int ldvl, float[] Vr, int ldvr) { + return LAPACKE_sgeev(layout.lapack(), jobvl.lapack(), jobvr.lapack(), n, A, lda, wr, wi, Vl, ldvl, Vr, ldvr); + } + + @Override + public int geev(Layout layout, EVDJob jobvl, EVDJob jobvr, int n, FloatBuffer A, int lda, FloatBuffer wr, FloatBuffer wi, FloatBuffer Vl, int ldvl, FloatBuffer Vr, int ldvr) { + return LAPACKE_sgeev(layout.lapack(), jobvl.lapack(), jobvr.lapack(), n, A, lda, wr, wi, Vl, ldvl, Vr, ldvr); + } + + @Override + public int syev(Layout layout, EVDJob jobz, UPLO uplo, int n, double[] A, int lda, double[] w) { + return LAPACKE_dsyev(layout.lapack(), jobz.lapack(), uplo.lapack(), n, A, lda, w); + } + + @Override + public int syev(Layout layout, EVDJob jobz, UPLO uplo, int n, DoubleBuffer A, int lda, DoubleBuffer w) { + return LAPACKE_dsyev(layout.lapack(), jobz.lapack(), uplo.lapack(), n, A, lda, w); + } + + @Override + public int syev(Layout layout, EVDJob jobz, UPLO uplo, int n, float[] A, int lda, float[] w) { + return LAPACKE_ssyev(layout.lapack(), jobz.lapack(), uplo.lapack(), n, A, lda, w); + } + + @Override + public int syev(Layout layout, EVDJob jobz, UPLO uplo, int n, FloatBuffer A, int lda, FloatBuffer w) { + return LAPACKE_ssyev(layout.lapack(), jobz.lapack(), uplo.lapack(), n, A, lda, w); + } + + @Override + public int syevd(Layout layout, EVDJob jobz, UPLO uplo, int n, double[] A, int lda, double[] w) { + return LAPACKE_dsyevd(layout.lapack(), jobz.lapack(), uplo.lapack(), n, A, lda, w); + } + + @Override + public int syevd(Layout layout, EVDJob jobz, UPLO uplo, int n, DoubleBuffer A, int lda, DoubleBuffer w) { + return LAPACKE_dsyevd(layout.lapack(), jobz.lapack(), uplo.lapack(), n, A, lda, w); + } + + @Override + public int syevd(Layout layout, EVDJob jobz, UPLO uplo, int n, float[] A, int lda, float[] w) { + return LAPACKE_ssyevd(layout.lapack(), jobz.lapack(), uplo.lapack(), n, A, lda, w); + } + + @Override + public int syevd(Layout layout, EVDJob jobz, UPLO uplo, int n, FloatBuffer A, int lda, FloatBuffer w) { + return LAPACKE_ssyevd(layout.lapack(), jobz.lapack(), uplo.lapack(), n, A, lda, w); + } + + @Override + public int syevr(Layout layout, EVDJob jobz, EigenRange range, UPLO uplo, int n, double[] A, int lda, double vl, double vu, int il, int iu, double abstol, int[] m, double[] w, double[] Z, int ldz, int[] isuppz) { + return LAPACKE_dsyevr(layout.lapack(), jobz.lapack(), range.lapack(), uplo.lapack(), n, A, lda, vl, vu, il, iu, abstol, m, w, Z, ldz, isuppz); + } + + @Override + public int syevr(Layout layout, EVDJob jobz, EigenRange range, UPLO uplo, int n, DoubleBuffer A, int lda, double vl, double vu, int il, int iu, double abstol, IntBuffer m, DoubleBuffer w, DoubleBuffer Z, int ldz, IntBuffer isuppz) { + return LAPACKE_dsyevr(layout.lapack(), jobz.lapack(), range.lapack(), uplo.lapack(), n, A, lda, vl, vu, il, iu, abstol, m, w, Z, ldz, isuppz); + } + + @Override + public int syevr(Layout layout, EVDJob jobz, EigenRange range, UPLO uplo, int n, float[] A, int lda, float vl, float vu, int il, int iu, float abstol, int[] m, float[] w, float[] Z, int ldz, int[] isuppz) { + return LAPACKE_ssyevr(layout.lapack(), jobz.lapack(), range.lapack(), uplo.lapack(), n, A, lda, vl, vu, il, iu, abstol, m, w, Z, ldz, isuppz); + } + + @Override + public int syevr(Layout layout, EVDJob jobz, EigenRange range, UPLO uplo, int n, FloatBuffer A, int lda, float vl, float vu, int il, int iu, float abstol, IntBuffer m, FloatBuffer w, FloatBuffer Z, int ldz, IntBuffer isuppz) { + return LAPACKE_ssyevr(layout.lapack(), jobz.lapack(), range.lapack(), uplo.lapack(), n, A, lda, vl, vu, il, iu, abstol, m, w, Z, ldz, isuppz); + } + + @Override + public int gesvd(Layout layout, SVDJob jobu, SVDJob jobvt, int m, int n, double[] A, int lda, double[] s, double[] U, int ldu, double[] VT, int ldvt, double[] superb) { + return LAPACKE_dgesvd(layout.lapack(), jobu.lapack(), jobvt.lapack(), m, n, A, lda, s, U, ldu, VT, ldvt, superb); + } + + @Override + public int gesvd(Layout layout, SVDJob jobu, SVDJob jobvt, int m, int n, DoubleBuffer A, int lda, DoubleBuffer s, DoubleBuffer U, int ldu, DoubleBuffer VT, int ldvt, DoubleBuffer superb) { + return LAPACKE_dgesvd(layout.lapack(), jobu.lapack(), jobvt.lapack(), m, n, A, lda, s, U, ldu, VT, ldvt, superb); + } + + @Override + public int gesvd(Layout layout, SVDJob jobu, SVDJob jobvt, int m, int n, float[] A, int lda, float[] s, float[] U, int ldu, float[] VT, int ldvt, float[] superb) { + return LAPACKE_sgesvd(layout.lapack(), jobu.lapack(), jobvt.lapack(), m, n, A, lda, s, U, ldu, VT, ldvt, superb); + } + + @Override + public int gesvd(Layout layout, SVDJob jobu, SVDJob jobvt, int m, int n, FloatBuffer A, int lda, FloatBuffer s, FloatBuffer U, int ldu, FloatBuffer VT, int ldvt, FloatBuffer superb) { + return LAPACKE_sgesvd(layout.lapack(), jobu.lapack(), jobvt.lapack(), m, n, A, lda, s, U, ldu, VT, ldvt, superb); + } + + @Override + public int gesdd(Layout layout, SVDJob jobz, int m, int n, double[] A, int lda, double[] s, double[] U, int ldu, double[] VT, int ldvt) { + return LAPACKE_dgesdd(layout.lapack(), jobz.lapack(), m, n, A, lda, s, U, ldu, VT, ldvt); + } + + @Override + public int gesdd(Layout layout, SVDJob jobz, int m, int n, DoubleBuffer A, int lda, DoubleBuffer s, DoubleBuffer U, int ldu, DoubleBuffer VT, int ldvt) { + return LAPACKE_dgesdd(layout.lapack(), jobz.lapack(), m, n, A, lda, s, U, ldu, VT, ldvt); + } + + @Override + public int gesdd(Layout layout, SVDJob jobz, int m, int n, float[] A, int lda, float[] s, float[] U, int ldu, float[] VT, int ldvt) { + return LAPACKE_sgesdd(layout.lapack(), jobz.lapack(), m, n, A, lda, s, U, ldu, VT, ldvt); + } + + @Override + public int gesdd(Layout layout, SVDJob jobz, int m, int n, FloatBuffer A, int lda, FloatBuffer s, FloatBuffer U, int ldu, FloatBuffer VT, int ldvt) { + return LAPACKE_sgesdd(layout.lapack(), jobz.lapack(), m, n, A, lda, s, U, ldu, VT, ldvt); + } + + @Override + public int getrf(Layout layout, int m, int n, DoubleBuffer A, int lda, IntBuffer ipiv) { + return LAPACKE_dgetrf(layout.lapack(), m, n, A, lda, ipiv); + } + + @Override + public int getrf(Layout layout, int m, int n, double[] A, int lda, int[] ipiv) { + return LAPACKE_dgetrf(layout.lapack(), m, n, A, lda, ipiv); + } + + @Override + public int getrf(Layout layout, int m, int n, float[] A, int lda, int[] ipiv) { + return LAPACKE_sgetrf(layout.lapack(), m, n, A, lda, ipiv); + } + + @Override + public int getrf(Layout layout, int m, int n, FloatBuffer A, int lda, IntBuffer ipiv) { + return LAPACKE_sgetrf(layout.lapack(), m, n, A, lda, ipiv); + } + + @Override + public int getrf2(Layout layout, int m, int n, double[] A, int lda, int[] ipiv) { + return LAPACKE_dgetrf2(layout.lapack(), m, n, A, lda, ipiv); + } + + @Override + public int getrf2(Layout layout, int m, int n, DoubleBuffer A, int lda, IntBuffer ipiv) { + return LAPACKE_dgetrf2(layout.lapack(), m, n, A, lda, ipiv); + } + + @Override + public int getrf2(Layout layout, int m, int n, float[] A, int lda, int[] ipiv) { + return LAPACKE_sgetrf2(layout.lapack(), m, n, A, lda, ipiv); + } + + @Override + public int getrf2(Layout layout, int m, int n, FloatBuffer A, int lda, IntBuffer ipiv) { + return LAPACKE_sgetrf2(layout.lapack(), m, n, A, lda, ipiv); + } + + @Override + public int gbtrf(Layout layout, int m, int n, int kl, int ku, double[] AB, int ldab, int[] ipiv) { + return LAPACKE_dgbtrf(layout.lapack(), m, n, kl, ku, AB, ldab, ipiv); + } + + @Override + public int gbtrf(Layout layout, int m, int n, int kl, int ku, DoubleBuffer AB, int ldab, IntBuffer ipiv) { + return LAPACKE_dgbtrf(layout.lapack(), m, n, kl, ku, AB, ldab, ipiv); + } + + @Override + public int gbtrf(Layout layout, int m, int n, int kl, int ku, float[] AB, int ldab, int[] ipiv) { + return LAPACKE_sgbtrf(layout.lapack(), m, n, kl, ku, AB, ldab, ipiv); + } + + @Override + public int gbtrf(Layout layout, int m, int n, int kl, int ku, FloatBuffer AB, int ldab, IntBuffer ipiv) { + return LAPACKE_sgbtrf(layout.lapack(), m, n, kl, ku, AB, ldab, ipiv); + } + + @Override + public int sptrf(Layout layout, UPLO uplo, int n, double[] AP, int[] ipiv) { + return LAPACKE_dsptrf(layout.lapack(), uplo.lapack(), n, AP, ipiv); + } + + @Override + public int sptrf(Layout layout, UPLO uplo, int n, DoubleBuffer AP, IntBuffer ipiv) { + return LAPACKE_dsptrf(layout.lapack(), uplo.lapack(), n, AP, ipiv); + } + + @Override + public int sptrf(Layout layout, UPLO uplo, int n, float[] AP, int[] ipiv) { + return LAPACKE_ssptrf(layout.lapack(), uplo.lapack(), n, AP, ipiv); + } + + @Override + public int sptrf(Layout layout, UPLO uplo, int n, FloatBuffer AP, IntBuffer ipiv) { + return LAPACKE_ssptrf(layout.lapack(), uplo.lapack(), n, AP, ipiv); + } + + @Override + public int getrs(Layout layout, Transpose trans, int n, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb) { + return LAPACKE_dgetrs(layout.lapack(), trans.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int getrs(Layout layout, Transpose trans, int n, int nrhs, DoubleBuffer A, int lda, IntBuffer ipiv, DoubleBuffer B, int ldb) { + return LAPACKE_dgetrs(layout.lapack(), trans.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int getrs(Layout layout, Transpose trans, int n, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb) { + return LAPACKE_sgetrs(layout.lapack(), trans.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int getrs(Layout layout, Transpose trans, int n, int nrhs, FloatBuffer A, int lda, IntBuffer ipiv, FloatBuffer B, int ldb) { + return LAPACKE_sgetrs(layout.lapack(), trans.lapack(), n, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gbtrs(Layout layout, Transpose trans, int n, int kl, int ku, int nrhs, double[] A, int lda, int[] ipiv, double[] B, int ldb) { + return LAPACKE_dgbtrs(layout.lapack(), trans.lapack(), n, kl, ku, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gbtrs(Layout layout, Transpose trans, int n, int kl, int ku, int nrhs, DoubleBuffer A, int lda, IntBuffer ipiv, DoubleBuffer B, int ldb) { + return LAPACKE_dgbtrs(layout.lapack(), trans.lapack(), n, kl, ku, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gbtrs(Layout layout, Transpose trans, int n, int kl, int ku, int nrhs, float[] A, int lda, int[] ipiv, float[] B, int ldb) { + return LAPACKE_sgbtrs(layout.lapack(), trans.lapack(), n, kl, ku, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int gbtrs(Layout layout, Transpose trans, int n, int kl, int ku, int nrhs, FloatBuffer A, int lda, IntBuffer ipiv, FloatBuffer B, int ldb) { + return LAPACKE_sgbtrs(layout.lapack(), trans.lapack(), n, kl, ku, nrhs, A, lda, ipiv, B, ldb); + } + + @Override + public int sptrs(Layout layout, UPLO uplo, int n, int nrhs, double[] AP, int[] ipiv, double[] B, int ldb) { + return LAPACKE_dsptrs(layout.lapack(), uplo.lapack(), n, nrhs, AP, ipiv, B, ldb); + } + + @Override + public int sptrs(Layout layout, UPLO uplo, int n, int nrhs, DoubleBuffer AP, IntBuffer ipiv, DoubleBuffer B, int ldb) { + return LAPACKE_dsptrs(layout.lapack(), uplo.lapack(), n, nrhs, AP, ipiv, B, ldb); + } + + @Override + public int sptrs(Layout layout, UPLO uplo, int n, int nrhs, float[] AP, int[] ipiv, float[] B, int ldb) { + return LAPACKE_ssptrs(layout.lapack(), uplo.lapack(), n, nrhs, AP, ipiv, B, ldb); + } + + @Override + public int sptrs(Layout layout, UPLO uplo, int n, int nrhs, FloatBuffer AP, IntBuffer ipiv, FloatBuffer B, int ldb) { + return LAPACKE_ssptrs(layout.lapack(), uplo.lapack(), n, nrhs, AP, ipiv, B, ldb); + } + + @Override + public int potrf(Layout layout, UPLO uplo, int n, double[] A, int lda) { + return LAPACKE_dpotrf(layout.lapack(), uplo.lapack(), n, A, lda); + } + + @Override + public int potrf(Layout layout, UPLO uplo, int n, DoubleBuffer A, int lda) { + return LAPACKE_dpotrf(layout.lapack(), uplo.lapack(), n, A, lda); + } + + @Override + public int potrf(Layout layout, UPLO uplo, int n, float[] A, int lda) { + return LAPACKE_spotrf(layout.lapack(), uplo.lapack(), n, A, lda); + } + + @Override + public int potrf(Layout layout, UPLO uplo, int n, FloatBuffer A, int lda) { + return LAPACKE_spotrf(layout.lapack(), uplo.lapack(), n, A, lda); + } + + @Override + public int potrf2(Layout layout, UPLO uplo, int n, double[] A, int lda) { + return LAPACKE_dpotrf2(layout.lapack(), uplo.lapack(), n, A, lda); + } + + @Override + public int potrf2(Layout layout, UPLO uplo, int n, DoubleBuffer A, int lda) { + return LAPACKE_dpotrf2(layout.lapack(), uplo.lapack(), n, A, lda); + } + + @Override + public int potrf2(Layout layout, UPLO uplo, int n, float[] A, int lda) { + return LAPACKE_spotrf2(layout.lapack(), uplo.lapack(), n, A, lda); + } + + @Override + public int potrf2(Layout layout, UPLO uplo, int n, FloatBuffer A, int lda) { + return LAPACKE_spotrf2(layout.lapack(), uplo.lapack(), n, A, lda); + } + + @Override + public int pbtrf(Layout layout, UPLO uplo, int n, int kd, double[] AB, int ldab) { + return LAPACKE_dpbtrf(layout.lapack(), uplo.lapack(), n, kd, AB, ldab); + } + + @Override + public int pbtrf(Layout layout, UPLO uplo, int n, int kd, DoubleBuffer AB, int ldab) { + return LAPACKE_dpbtrf(layout.lapack(), uplo.lapack(), n, kd, AB, ldab); + } + + @Override + public int pbtrf(Layout layout, UPLO uplo, int n, int kd, float[] AB, int ldab) { + return LAPACKE_spbtrf(layout.lapack(), uplo.lapack(), n, kd, AB, ldab); + } + + @Override + public int pbtrf(Layout layout, UPLO uplo, int n, int kd, FloatBuffer AB, int ldab) { + return LAPACKE_spbtrf(layout.lapack(), uplo.lapack(), n, kd, AB, ldab); + } + + @Override + public int pptrf(Layout layout, UPLO uplo, int n, double[] AP) { + return LAPACKE_dpptrf(layout.lapack(), uplo.lapack(), n, AP); + } + + @Override + public int pptrf(Layout layout, UPLO uplo, int n, DoubleBuffer AP) { + return LAPACKE_dpptrf(layout.lapack(), uplo.lapack(), n, AP); + } + + @Override + public int pptrf(Layout layout, UPLO uplo, int n, float[] AP) { + return LAPACKE_spptrf(layout.lapack(), uplo.lapack(), n, AP); + } + + @Override + public int pptrf(Layout layout, UPLO uplo, int n, FloatBuffer AP) { + return LAPACKE_spptrf(layout.lapack(), uplo.lapack(), n, AP); + } + + @Override + public int potrs(Layout layout, UPLO uplo, int n, int nrhs, double[] A, int lda, double[] B, int ldb) { + return LAPACKE_dpotrs(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int potrs(Layout layout, UPLO uplo, int n, int nrhs, DoubleBuffer A, int lda, DoubleBuffer B, int ldb) { + return LAPACKE_dpotrs(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int potrs(Layout layout, UPLO uplo, int n, int nrhs, float[] A, int lda, float[] B, int ldb) { + return LAPACKE_spotrs(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int potrs(Layout layout, UPLO uplo, int n, int nrhs, FloatBuffer A, int lda, FloatBuffer B, int ldb) { + return LAPACKE_spotrs(layout.lapack(), uplo.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int pbtrs(Layout layout, UPLO uplo, int n, int kd, int nrhs, double[] AB, int ldab, double[] B, int ldb) { + return LAPACKE_dpbtrs(layout.lapack(), uplo.lapack(), n, kd, nrhs, AB, ldab, B, ldb); + } + + @Override + public int pbtrs(Layout layout, UPLO uplo, int n, int kd, int nrhs, DoubleBuffer AB, int ldab, DoubleBuffer B, int ldb) { + return LAPACKE_dpbtrs(layout.lapack(), uplo.lapack(), n, kd, nrhs, AB, ldab, B, ldb); + } + + @Override + public int pbtrs(Layout layout, UPLO uplo, int n, int kd, int nrhs, float[] AB, int ldab, float[] B, int ldb) { + return LAPACKE_spbtrs(layout.lapack(), uplo.lapack(), n, kd, nrhs, AB, ldab, B, ldb); + } + + @Override + public int pbtrs(Layout layout, UPLO uplo, int n, int kd, int nrhs, FloatBuffer AB, int ldab, FloatBuffer B, int ldb) { + return LAPACKE_spbtrs(layout.lapack(), uplo.lapack(), n, kd, nrhs, AB, ldab, B, ldb); + } + + @Override + public int pptrs(Layout layout, UPLO uplo, int n, int nrhs, double[] AP, double[] B, int ldb) { + return LAPACKE_dpptrs(layout.lapack(), uplo.lapack(), n, nrhs, AP, B, ldb); + } + + @Override + public int pptrs(Layout layout, UPLO uplo, int n, int nrhs, DoubleBuffer AP, DoubleBuffer B, int ldb) { + return LAPACKE_dpptrs(layout.lapack(), uplo.lapack(), n, nrhs, AP, B, ldb); + } + + @Override + public int pptrs(Layout layout, UPLO uplo, int n, int nrhs, float[] AP, float[] B, int ldb) { + return LAPACKE_spptrs(layout.lapack(), uplo.lapack(), n, nrhs, AP, B, ldb); + } + + @Override + public int pptrs(Layout layout, UPLO uplo, int n, int nrhs, FloatBuffer AP, FloatBuffer B, int ldb) { + return LAPACKE_spptrs(layout.lapack(), uplo.lapack(), n, nrhs, AP, B, ldb); + } + + @Override + public int geqrf(Layout layout, int m, int n, double[] A, int lda, double[] tau) { + return LAPACKE_dgeqrf(layout.lapack(), m, n, A, lda, tau); + } + + @Override + public int geqrf(Layout layout, int m, int n, DoubleBuffer A, int lda, DoubleBuffer tau) { + return LAPACKE_dgeqrf(layout.lapack(), m, n, A, lda, tau); + } + + @Override + public int geqrf(Layout layout, int m, int n, float[] A, int lda, float[] tau) { + return LAPACKE_sgeqrf(layout.lapack(), m, n, A, lda, tau); + } + + @Override + public int geqrf(Layout layout, int m, int n, FloatBuffer A, int lda, FloatBuffer tau) { + return LAPACKE_sgeqrf(layout.lapack(), m, n, A, lda, tau); + } + + @Override + public int orgqr(Layout layout, int m, int n, int k, double[] A, int lda, double[] tau) { + return LAPACKE_dorgqr(layout.lapack(), m, n, k, A, lda, tau); + } + + @Override + public int orgqr(Layout layout, int m, int n, int k, DoubleBuffer A, int lda, DoubleBuffer tau) { + return LAPACKE_dorgqr(layout.lapack(), m, n, k, A, lda, tau); + } + + @Override + public int orgrq(Layout layout, int m, int n, int k, double[] A, int lda, double[] tau) { + return LAPACKE_dorgrq(layout.lapack(), m, n, k, A, lda, tau); + } + + @Override + public int orgrq(Layout layout, int m, int n, int k, DoubleBuffer A, int lda, DoubleBuffer tau) { + return LAPACKE_dorgrq(layout.lapack(), m, n, k, A, lda, tau); + } + + @Override + public int ormqr(Layout layout, Side side, Transpose trans, int m, int n, int k, double[] A, int lda, double[] tau, double[] C, int ldc) { + return LAPACKE_dormqr(layout.lapack(), side.lapack(), trans.lapack(), m, n, k, A, lda, tau, C, ldc); + } + @Override + public int ormqr(Layout layout, Side side, Transpose trans, int m, int n, int k, DoubleBuffer A, int lda, DoubleBuffer tau, DoubleBuffer C, int ldc) { + return LAPACKE_dormqr(layout.lapack(), side.lapack(), trans.lapack(), m, n, k, A, lda, tau, C, ldc); + } + + @Override + public int ormqr(Layout layout, Side side, Transpose trans, int m, int n, int k, float[] A, int lda, float[] tau, float[] C, int ldc) { + return LAPACKE_sormqr(layout.lapack(), side.lapack(), trans.lapack(), m, n, k, A, lda, tau, C, ldc); + } + + @Override + public int ormqr(Layout layout, Side side, Transpose trans, int m, int n, int k, FloatBuffer A, int lda, FloatBuffer tau, FloatBuffer C, int ldc) { + return LAPACKE_sormqr(layout.lapack(), side.lapack(), trans.lapack(), m, n, k, A, lda, tau, C, ldc); + } + + @Override + public int trtrs(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, int nrhs, double[] A, int lda, double[] B, int ldb) { + return LAPACKE_dtrtrs(layout.lapack(), uplo.lapack(), trans.lapack(), diag.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int trtrs(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, int nrhs, DoubleBuffer A, int lda, DoubleBuffer B, int ldb) { + return LAPACKE_dtrtrs(layout.lapack(), uplo.lapack(), trans.lapack(), diag.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int trtrs(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, int nrhs, float[] A, int lda, float[] B, int ldb) { + return LAPACKE_strtrs(layout.lapack(), uplo.lapack(), trans.lapack(), diag.lapack(), n, nrhs, A, lda, B, ldb); + } + + @Override + public int trtrs(Layout layout, UPLO uplo, Transpose trans, Diag diag, int n, int nrhs, FloatBuffer A, int lda, FloatBuffer B, int ldb) { + return LAPACKE_strtrs(layout.lapack(), uplo.lapack(), trans.lapack(), diag.lapack(), n, nrhs, A, lda, B, ldb); + } +} diff --git a/meteoinfo-ndarray/src/main/java/org/meteoinfo/ndarray/math/ArrayMath.java b/meteoinfo-ndarray/src/main/java/org/meteoinfo/ndarray/math/ArrayMath.java index 39541f47..206aaeae 100644 --- a/meteoinfo-ndarray/src/main/java/org/meteoinfo/ndarray/math/ArrayMath.java +++ b/meteoinfo-ndarray/src/main/java/org/meteoinfo/ndarray/math/ArrayMath.java @@ -6729,7 +6729,50 @@ public class ArrayMath { ranges.add(new Range(current[idx], current[idx], 1)); } } - s = sum(a, ranges); + s = sumRange(a, ranges); + r.setDouble(i, s); + indexr.incr(); + } + + return r; + } + + /** + * Compute sum value of an array along axes (dimension) + * + * @param a Array a + * @param axes Axes + * @return Sum value array + * @throws InvalidRangeException + */ + public static Array sum(Array a, List axes) throws InvalidRangeException { + int[] dataShape = a.getShape(); + int[] shape = new int[dataShape.length - axes.size()]; + int idx = 0; + for (int i = 0; i < dataShape.length; i++) { + if (axes.contains(i)) { + continue; + } + shape[idx] = dataShape[i]; + idx += 1; + } + Array r = Array.factory(a.getDataType(), shape); + double s; + Index indexr = r.getIndex(); + int[] current; + for (int i = 0; i < r.getSize(); i++) { + current = indexr.getCurrentCounter(); + List ranges = new ArrayList<>(); + idx = 0; + for (int j = 0; j < dataShape.length; j++) { + if (axes.contains(j)) { + ranges.add(new Range(0, dataShape[j] - 1, 1)); + } else { + ranges.add(new Range(current[idx], current[idx], 1)); + idx += 1; + } + } + s = sumRange(a, ranges); r.setDouble(i, s); indexr.incr(); } @@ -6745,7 +6788,7 @@ public class ArrayMath { * @return Sum value * @throws InvalidRangeException */ - public static double sum(Array a, List ranges) throws InvalidRangeException { + public static double sumRange(Array a, List ranges) throws InvalidRangeException { double s = 0.0, v; int n = 0; IndexIterator ii = a.getRangeIterator(ranges); @@ -6763,7 +6806,7 @@ public class ArrayMath { } /** - * Compute the sum arry from a list of arrays + * Compute the sum array from a list of arrays * * @param alist list of arrays * @return Sum array