lapack_impl.h

/* -*- mode: C; c-basic-offset: 4 -*- */
/* ex: set shiftwidth=4 tabstop=4 expandtab: */
/*
 * Copyright (c) 2008-2012, Georgia Tech Research Corporation
 * All rights reserved.
 *
 * Author(s): Neil T. Dantam <ntd@gatech.edu>
 * Georgia Tech Humanoid Robotics Lab
 * Under Direction of Prof. Mike Stilman <mstilman@cc.gatech.edu>
 *
 *
 * This file is provided under the following "BSD-style" License:
 *
 *
 *   Redistribution and use in source and binary forms, with or
 *   without modification, are permitted provided that the following
 *   conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *   POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "amino/def.h"

/* FILE lapack_impl.h
 * BRIEF: C prototypes to various fortran lapack routines.
 *
 * Since there is no official c binding to lapack as there as with
 * BLAS, the only reasonable way to interface with lapack from C is to
 * call the fortran methods directly.
 *
 * Authors:
 *   Neil T. Dantam
 */

AA_API void AA_LAPACK_NAME(getri)
( const int *N, AA_TYPE *A, const int *LDA,
  const int *IPIV, AA_TYPE *WORK, const int *LWORK, int *INFO );

AA_API void AA_LAPACK_NAME(getrf)
( const int *M, const int *N, AA_TYPE *A, const int *LDA,
  int *IPIV, int *INFO );

AA_API void AA_LAPACK_NAME(geqrf)
( const int *M, const int *N, AA_TYPE *A, const int *LDA,
  AA_TYPE *TAU, AA_TYPE *WORK, int *LWORK, int *INFO );

AA_API void AA_LAPACK_NAME(orgqr)
( const int *M, const int *N, const int *K,
  AA_TYPE *A, const int *LDA, const AA_TYPE *TAU,
  AA_TYPE *WORK, const int *LWORK, int *INFO );


AA_API void AA_LAPACK_NAME(posv)
( const char UPLO[1], const int *N, const int *NRHS,
  AA_TYPE *A, const int *LDA,
  AA_TYPE *B, const int *LDB,
  int *INFO );

AA_API void AA_LAPACK_NAME(gesvd)
( const char jobu[1], const char jobvt[1],
  const int *m, const int *n,
  AA_TYPE *A, const int *lda,
  AA_TYPE *S, AA_TYPE *U,
  const int *ldu, AA_TYPE *Vt, const int *ldvt,
  AA_TYPE *work, const int *lwork, int *info );

AA_API void AA_LAPACK_NAME(gesdd)
(const char *JOBZ, const int *M, const int *N,
 AA_TYPE *A, const int *LDA,
 AA_TYPE *S,
 AA_TYPE *U, const int *LDU,
 AA_TYPE *VT, const int * LDVT,
 AA_TYPE *WORK, const int *LWORK,
 int *IWORK, int *INFO);

AA_API int AA_LAPACK_NAME(geev)
(const char *jobvl, const char *jobvr,
 int *n, AA_TYPE *a, int *lda,
 AA_TYPE *wr, AA_TYPE *wi,
 AA_TYPE *vl, int *ldvl,
 AA_TYPE *vr, int *ldvr,
 AA_TYPE *work, int *lwork, int *info);



AA_API void AA_LAPACK_NAME(gelsd)
( const int *M, const int *N, const int *NRHS,
  AA_TYPE *A, const int *LDA, AA_TYPE *B, const int *LDB,
  AA_TYPE *S, const AA_TYPE *RCOND, int *RANK,
  AA_TYPE *WORK, int *LWORK, int *IWORK, int *INFO );


AA_API void AA_LAPACK_NAME(gebal)
( const char JOB[1], int *N, AA_TYPE *A, const int *LDA,
  int *ILO, int *IHI, AA_TYPE *SCALE, int *INFO );


AA_API void AA_LAPACK_NAME(gees)
( const char JOBVS[1], const char SORT[1],
  int (*SELECT)(const AA_TYPE*,const AA_TYPE*),
  const int *N, AA_TYPE *A, const int *LDA, int *SDIM,
  AA_TYPE *WR, AA_TYPE *WI,
  AA_TYPE *VS, const int *LDVS,
  AA_TYPE *WORK, const int *LWORK, int *BWORK, int *INFO );

AA_API void AA_LAPACK_NAME(gels)
( const char TRANS[1], const int *M, const int *N, const int *NRHS,
  AA_TYPE *A, const int *LDA, AA_TYPE *B, const int *LDB, AA_TYPE *WORK,
  const int *LWORK, int *INFO );

/*
*  DPOTRF computes the Cholesky factorization of a real symmetric
*  positive definite matrix A.
*
*  The factorization has the form
*     \f[ A = U^T * U \f]  if UPLO = 'U'
*       or
*     \f[ A = L  * L^T \f]  if UPLO = 'L'
*
*  where U is an upper triangular matrix and L is lower triangular.
*
*  This is the block version of the algorithm, calling Level 3 BLAS.
*
*
*  \param[in] UPLO
*          = 'U':  Upper triangle of A is stored;
*          = 'L':  Lower triangle of A is stored.
*
*  \param[in] N
*          The order of the matrix A.  N >= 0.
*
*  \param[inout] A
*          On entry, the symmetric matrix A.  If UPLO = 'U', the leading
*          N-by-N upper triangular part of A contains the upper
*          triangular part of the matrix A, and the strictly lower
*          triangular part of A is not referenced.  If UPLO = 'L', the
*          leading N-by-N lower triangular part of A contains the lower
*          triangular part of the matrix A, and the strictly upper
*          triangular part of A is not referenced.
*          On exit, if INFO = 0, the factor U or L from the Cholesky
*          factorization A = U**T*U or A = L*L**T.
*
*  \param[in] LDA
*          The leading dimension of the array A.  LDA >= max(1,N).
*
*  \param[out] INFO
*        - = 0:  successful exit
*        - < 0:  if INFO = -i, the i-th argument had an illegal value
*        - > 0:  if INFO = i, the leading minor of order i is not
*                positive definite, and the factorization could not be
*                completed.
*/

AA_API void AA_LAPACK_NAME(potrf)
( const char UPLO[1], const int *N,
  AA_TYPE *A, const int *LDA,
  int *INFO );

AA_API void AA_LAPACK_NAME(potrs)
( const char UPLO[1], const int *N, const int *nrhs,
  AA_TYPE *A, const int *LDA,
  AA_TYPE *B, const int *LDB,
  int *INFO );

AA_API void AA_LAPACK_NAME(lacpy)
( const char UPLO[1], const int *M, const int *N,
  const AA_TYPE *A, const int *LDA, AA_TYPE *B, const int *LDB );


AA_API AA_TYPE AA_LAPACK_NAME(lapy2)
( const AA_TYPE *x, const AA_TYPE *y );

AA_API AA_TYPE AA_LAPACK_NAME(lapy3)
( const AA_TYPE *x, const AA_TYPE *y, const AA_TYPE *z );


AA_API void AA_LAPACK_NAME(laruv)
( int ISEED[4], const int *N, AA_TYPE *X );

AA_API void AA_LAPACK_NAME(larnv)
( const int *IDIST, int ISEED[4],
  const int *N, AA_TYPE *X );

AA_API void AA_LAPACK_NAME(lascl)
( const char TYPE[1], const int *KL, const int *KU,
  const AA_TYPE *CFROM, const AA_TYPE *CTO,
  const int *M, const int *N, AA_TYPE *A, const int *LDA,
  int *INFO );

AA_API void AA_LAPACK_NAME(laset)
( const char UPLO[1], const int *M, const int *N,
  const AA_TYPE *ALPHA,
  const AA_TYPE *BETA,
  AA_TYPE *A, const int *LDA );





#include "amino/undef.h"

#if AA_TYPE == double

AA_API void dlag2s_ ( const int *M, const int *N,
                      double *A, const int *LDA,
                      float *SA, const int *LDSA,
                      const int *INFO );


#endif // AA_TYPE == double


#if AA_TYPE == float

AA_API void slag2d_ ( const int *M, const int *N,
                      float *SA, const int *LDSA,
                      double *A, const int *LDA,
                      const int *INFO );

#endif // AA_TYPE == float