//   Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "paddle/phi/kernels/funcs/lapack/lapack_function.h"

#include "paddle/phi/backends/dynload/lapack.h"
#include "paddle/phi/common/data_type.h"

namespace phi::funcs {

// LU (for example)
template <>
void lapackLu<double>(int m, int n, double *a, int lda, int *ipiv, int *info) {
  dynload::dgetrf_(&m, &n, a, &lda, ipiv, info);
}

template <>
void lapackLu<float>(int m, int n, float *a, int lda, int *ipiv, int *info) {
  dynload::sgetrf_(&m, &n, a, &lda, ipiv, info);
}

template <>
void lapackLu<phi::complex64>(
    int m, int n, phi::complex64 *a, int lda, int *ipiv, int *info) {
  dynload::cgetrf_(
      &m, &n, reinterpret_cast<std::complex<float> *>(a), &lda, ipiv, info);
}

template <>
void lapackLu<phi::complex128>(
    int m, int n, phi::complex128 *a, int lda, int *ipiv, int *info) {
  dynload::zgetrf_(
      &m, &n, reinterpret_cast<std::complex<double> *>(a), &lda, ipiv, info);
}

// lu_solve
template <>
void lapackLuSolve<double>(char trans,
                           int n,
                           int nrhs,
                           double *a,
                           int lda,
                           int *ipiv,
                           double *b,
                           int ldb,
                           int *info) {
  dynload::dgetrs_(&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info);
}

template <>
void lapackLuSolve<float>(char trans,
                          int n,
                          int nrhs,
                          float *a,
                          int lda,
                          int *ipiv,
                          float *b,
                          int ldb,
                          int *info) {
  dynload::sgetrs_(&trans, &n, &nrhs, a, &lda, ipiv, b, &ldb, info);
}

template <>
void lapackLuSolve<phi::complex64>(char trans,
                                   int n,
                                   int nrhs,
                                   phi::complex64 *a,
                                   int lda,
                                   int *ipiv,
                                   phi::complex64 *b,
                                   int ldb,
                                   int *info) {
  dynload::cgetrs_(&trans,
                   &n,
                   &nrhs,
                   reinterpret_cast<std::complex<float> *>(a),
                   &lda,
                   ipiv,
                   reinterpret_cast<std::complex<float> *>(b),
                   &ldb,
                   info);
}

template <>
void lapackLuSolve<phi::complex128>(char trans,
                                    int n,
                                    int nrhs,
                                    phi::complex128 *a,
                                    int lda,
                                    int *ipiv,
                                    phi::complex128 *b,
                                    int ldb,
                                    int *info) {
  dynload::zgetrs_(&trans,
                   &n,
                   &nrhs,
                   reinterpret_cast<std::complex<double> *>(a),
                   &lda,
                   ipiv,
                   reinterpret_cast<std::complex<double> *>(b),
                   &ldb,
                   info);
}

// eigh
template <>
void lapackEigh<float>(char jobz,
                       char uplo,
                       int n,
                       float *a,
                       int lda,
                       float *w,
                       float *work,
                       int lwork,
                       float *rwork,
                       int lrwork,
                       int *iwork,
                       int liwork,
                       int *info) {
  (void)rwork;   // unused
  (void)lrwork;  // unused
  dynload::ssyevd_(
      &jobz, &uplo, &n, a, &lda, w, work, &lwork, iwork, &liwork, info);
}

template <>
void lapackEigh<double>(char jobz,
                        char uplo,
                        int n,
                        double *a,
                        int lda,
                        double *w,
                        double *work,
                        int lwork,
                        double *rwork,
                        int lrwork,
                        int *iwork,
                        int liwork,
                        int *info) {
  (void)rwork;   // unused
  (void)lrwork;  // unused
  dynload::dsyevd_(
      &jobz, &uplo, &n, a, &lda, w, work, &lwork, iwork, &liwork, info);
}

template <>
void lapackEigh<phi::complex64, float>(char jobz,
                                       char uplo,
                                       int n,
                                       phi::complex64 *a,
                                       int lda,
                                       float *w,
                                       phi::complex64 *work,
                                       int lwork,
                                       float *rwork,
                                       int lrwork,
                                       int *iwork,
                                       int liwork,
                                       int *info) {
  dynload::cheevd_(&jobz,
                   &uplo,
                   &n,
                   reinterpret_cast<std::complex<float> *>(a),
                   &lda,
                   w,
                   reinterpret_cast<std::complex<float> *>(work),
                   &lwork,
                   rwork,
                   &lrwork,
                   iwork,
                   &liwork,
                   info);
}

template <>
void lapackEigh<phi::complex128, double>(char jobz,
                                         char uplo,
                                         int n,
                                         phi::complex128 *a,
                                         int lda,
                                         double *w,
                                         phi::complex128 *work,
                                         int lwork,
                                         double *rwork,
                                         int lrwork,
                                         int *iwork,
                                         int liwork,
                                         int *info) {
  dynload::zheevd_(&jobz,
                   &uplo,
                   &n,
                   reinterpret_cast<std::complex<double> *>(a),
                   &lda,
                   w,
                   reinterpret_cast<std::complex<double> *>(work),
                   &lwork,
                   rwork,
                   &lrwork,
                   iwork,
                   &liwork,
                   info);
}

// Eig
template <>
void lapackEig<double>(char jobvl,
                       char jobvr,
                       int n,
                       double *a,
                       int lda,
                       double *w,
                       double *vl,
                       int ldvl,
                       double *vr,
                       int ldvr,
                       double *work,
                       int lwork,
                       double *rwork,
                       int *info) {
  double *wr = w;
  double *wi = w + n;
  (void)rwork;  // unused
  dynload::dgeev_(&jobvl,
                  &jobvr,
                  &n,
                  a,
                  &lda,
                  wr,
                  wi,
                  vl,
                  &ldvl,
                  vr,
                  &ldvr,
                  work,
                  &lwork,
                  info);
}

template <>
void lapackEig<float>(char jobvl,
                      char jobvr,
                      int n,
                      float *a,
                      int lda,
                      float *w,
                      float *vl,
                      int ldvl,
                      float *vr,
                      int ldvr,
                      float *work,
                      int lwork,
                      float *rwork,
                      int *info) {
  float *wr = w;
  float *wi = w + n;
  (void)rwork;  // unused
  dynload::sgeev_(&jobvl,
                  &jobvr,
                  &n,
                  a,
                  &lda,
                  wr,
                  wi,
                  vl,
                  &ldvl,
                  vr,
                  &ldvr,
                  work,
                  &lwork,
                  info);
}

template <>
void lapackEig<phi::complex128, double>(char jobvl,
                                        char jobvr,
                                        int n,
                                        phi::complex128 *a,
                                        int lda,
                                        phi::complex128 *w,
                                        phi::complex128 *vl,
                                        int ldvl,
                                        phi::complex128 *vr,
                                        int ldvr,
                                        phi::complex128 *work,
                                        int lwork,
                                        double *rwork,
                                        int *info) {
  dynload::zgeev_(&jobvl,
                  &jobvr,
                  &n,
                  reinterpret_cast<std::complex<double> *>(a),
                  &lda,
                  reinterpret_cast<std::complex<double> *>(w),
                  reinterpret_cast<std::complex<double> *>(vl),
                  &ldvl,
                  reinterpret_cast<std::complex<double> *>(vr),
                  &ldvr,
                  reinterpret_cast<std::complex<double> *>(work),
                  &lwork,
                  rwork,
                  info);
}

template <>
void lapackEig<phi::complex64, float>(char jobvl,
                                      char jobvr,
                                      int n,
                                      phi::complex64 *a,
                                      int lda,
                                      phi::complex64 *w,
                                      phi::complex64 *vl,
                                      int ldvl,
                                      phi::complex64 *vr,
                                      int ldvr,
                                      phi::complex64 *work,
                                      int lwork,
                                      float *rwork,
                                      int *info) {
  dynload::cgeev_(&jobvl,
                  &jobvr,
                  &n,
                  reinterpret_cast<std::complex<float> *>(a),
                  &lda,
                  reinterpret_cast<std::complex<float> *>(w),
                  reinterpret_cast<std::complex<float> *>(vl),
                  &ldvl,
                  reinterpret_cast<std::complex<float> *>(vr),
                  &ldvr,
                  reinterpret_cast<std::complex<float> *>(work),
                  &lwork,
                  rwork,
                  info);
}

template <>
void lapackGels<double>(char trans,
                        int m,
                        int n,
                        int nrhs,
                        double *a,
                        int lda,
                        double *b,
                        int ldb,
                        double *work,
                        int lwork,
                        int *info) {
  dynload::dgels_(&trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork, info);
}

template <>
void lapackGels<float>(char trans,
                       int m,
                       int n,
                       int nrhs,
                       float *a,
                       int lda,
                       float *b,
                       int ldb,
                       float *work,
                       int lwork,
                       int *info) {
  dynload::sgels_(&trans, &m, &n, &nrhs, a, &lda, b, &ldb, work, &lwork, info);
}

template <>
void lapackGelsd<double>(int m,
                         int n,
                         int nrhs,
                         double *a,
                         int lda,
                         double *b,
                         int ldb,
                         double *s,
                         double rcond,
                         int *rank,
                         double *work,
                         int lwork,
                         double *rwork,
                         int *iwork,
                         int *info) {
  dynload::dgelsd_(&m,
                   &n,
                   &nrhs,
                   a,
                   &lda,
                   b,
                   &ldb,
                   s,
                   &rcond,
                   rank,
                   work,
                   &lwork,
                   iwork,
                   info);
}

template <>
void lapackGelsd<float>(int m,
                        int n,
                        int nrhs,
                        float *a,
                        int lda,
                        float *b,
                        int ldb,
                        float *s,
                        float rcond,
                        int *rank,
                        float *work,
                        int lwork,
                        float *rwork,
                        int *iwork,
                        int *info) {
  dynload::sgelsd_(&m,
                   &n,
                   &nrhs,
                   a,
                   &lda,
                   b,
                   &ldb,
                   s,
                   &rcond,
                   rank,
                   work,
                   &lwork,
                   iwork,
                   info);
}

template <>
void lapackGelsy<double>(int m,
                         int n,
                         int nrhs,
                         double *a,
                         int lda,
                         double *b,
                         int ldb,
                         int *jpvt,
                         double rcond,
                         int *rank,
                         double *work,
                         int lwork,
                         double *rwork,
                         int *info) {
  dynload::dgelsy_(
      &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, rank, work, &lwork, info);
}

template <>
void lapackGelsy<float>(int m,
                        int n,
                        int nrhs,
                        float *a,
                        int lda,
                        float *b,
                        int ldb,
                        int *jpvt,
                        float rcond,
                        int *rank,
                        float *work,
                        int lwork,
                        float *rwork,
                        int *info) {
  dynload::sgelsy_(
      &m, &n, &nrhs, a, &lda, b, &ldb, jpvt, &rcond, rank, work, &lwork, info);
}

template <>
void lapackGelss<double>(int m,
                         int n,
                         int nrhs,
                         double *a,
                         int lda,
                         double *b,
                         int ldb,
                         double *s,
                         double rcond,
                         int *rank,
                         double *work,
                         int lwork,
                         double *rwork,
                         int *info) {
  dynload::dgelss_(
      &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, info);
}

template <>
void lapackGelss<float>(int m,
                        int n,
                        int nrhs,
                        float *a,
                        int lda,
                        float *b,
                        int ldb,
                        float *s,
                        float rcond,
                        int *rank,
                        float *work,
                        int lwork,
                        float *rwork,
                        int *info) {
  dynload::sgelss_(
      &m, &n, &nrhs, a, &lda, b, &ldb, s, &rcond, rank, work, &lwork, info);
}

template <>
void lapackCholeskySolve<phi::complex128>(char uplo,
                                          int n,
                                          int nrhs,
                                          phi::complex128 *a,
                                          int lda,
                                          phi::complex128 *b,
                                          int ldb,
                                          int *info) {
  dynload::zpotrs_(&uplo,
                   &n,
                   &nrhs,
                   reinterpret_cast<std::complex<double> *>(a),
                   &lda,
                   reinterpret_cast<std::complex<double> *>(b),
                   &ldb,
                   info);
}

template <>
void lapackCholeskySolve<phi::complex64>(char uplo,
                                         int n,
                                         int nrhs,
                                         phi::complex64 *a,
                                         int lda,
                                         phi::complex64 *b,
                                         int ldb,
                                         int *info) {
  dynload::cpotrs_(&uplo,
                   &n,
                   &nrhs,
                   reinterpret_cast<std::complex<float> *>(a),
                   &lda,
                   reinterpret_cast<std::complex<float> *>(b),
                   &ldb,
                   info);
}

template <>
void lapackCholeskySolve<double>(char uplo,
                                 int n,
                                 int nrhs,
                                 double *a,
                                 int lda,
                                 double *b,
                                 int ldb,
                                 int *info) {
  dynload::dpotrs_(&uplo, &n, &nrhs, a, &lda, b, &ldb, info);
}

template <>
void lapackCholeskySolve<float>(char uplo,
                                int n,
                                int nrhs,
                                float *a,
                                int lda,
                                float *b,
                                int ldb,
                                int *info) {
  dynload::spotrs_(&uplo, &n, &nrhs, a, &lda, b, &ldb, info);
}

template <>
void lapackSvd<double>(char jobz,
                       int m,
                       int n,
                       double *a,
                       int lda,
                       double *s,
                       double *u,
                       int ldu,
                       double *vt,
                       int ldvt,
                       double *work,
                       int lwork,
                       double *rwork,
                       int *iwork,
                       int *info) {
  (void)rwork;  // unused
  dynload::dgesdd_(
      &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, iwork, info);
}

template <>
void lapackSvd<float>(char jobz,
                      int m,
                      int n,
                      float *a,
                      int lda,
                      float *s,
                      float *u,
                      int ldu,
                      float *vt,
                      int ldvt,
                      float *work,
                      int lwork,
                      float *rwork,
                      int *iwork,
                      int *info) {
  (void)rwork;  // unused
  dynload::sgesdd_(
      &jobz, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, iwork, info);
}

template <>
void lapackSvd<phi::complex128, double>(char jobz,
                                        int m,
                                        int n,
                                        phi::complex128 *a,
                                        int lda,
                                        double *s,
                                        phi::complex128 *u,
                                        int ldu,
                                        phi::complex128 *vt,
                                        int ldvt,
                                        phi::complex128 *work,
                                        int lwork,
                                        double *rwork,
                                        int *iwork,
                                        int *info) {
  dynload::zgesdd_(&jobz,
                   &m,
                   &n,
                   reinterpret_cast<std::complex<double> *>(a),
                   &lda,
                   reinterpret_cast<std::complex<double> *>(s),
                   reinterpret_cast<std::complex<double> *>(u),
                   &ldu,
                   reinterpret_cast<std::complex<double> *>(vt),
                   &ldvt,
                   reinterpret_cast<std::complex<double> *>(work),
                   &lwork,
                   rwork,
                   iwork,
                   info);
}

template <>
void lapackSvd<phi::complex64, float>(char jobz,
                                      int m,
                                      int n,
                                      phi::complex64 *a,
                                      int lda,
                                      float *s,
                                      phi::complex64 *u,
                                      int ldu,
                                      phi::complex64 *vt,
                                      int ldvt,
                                      phi::complex64 *work,
                                      int lwork,
                                      float *rwork,
                                      int *iwork,
                                      int *info) {
  dynload::cgesdd_(&jobz,
                   &m,
                   &n,
                   reinterpret_cast<std::complex<float> *>(a),
                   &lda,
                   reinterpret_cast<std::complex<float> *>(s),
                   reinterpret_cast<std::complex<float> *>(u),
                   &ldu,
                   reinterpret_cast<std::complex<float> *>(vt),
                   &ldvt,
                   reinterpret_cast<std::complex<float> *>(work),
                   &lwork,
                   rwork,
                   iwork,
                   info);
}

}  // namespace phi::funcs