"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "include/armadillo_bits/translate_atlas.hpp" between
armadillo-10.8.2.tar.xz and armadillo-11.0.0.tar.xz

About: Armadillo is a C++ linear algebra library (matrix maths) aiming towards a good balance between speed and ease of use.

translate_atlas.hpp  (armadillo-10.8.2.tar.xz):translate_atlas.hpp  (armadillo-11.0.0.tar.xz)
skipping to change at line 18 skipping to change at line 18
// You may obtain a copy of the License at // You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0 // http://www.apache.org/licenses/LICENSE-2.0
// //
// Unless required by applicable law or agreed to in writing, software // Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, // distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
#ifdef ARMA_USE_ATLAS #if defined(ARMA_USE_ATLAS)
//! \namespace atlas namespace for ATLAS functions (imported from the global nam // TODO: remove support for ATLAS in next major version
espace)
//! \namespace atlas namespace for ATLAS functions
namespace atlas namespace atlas
{ {
template<typename eT> template<typename eT>
inline static const eT& tmp_real(const eT& X) { return X; } inline static const eT& tmp_real(const eT& X) { return X; }
template<typename T> template<typename T>
inline static const T tmp_real(const std::complex<T>& X) { return X.real(); } inline static const T tmp_real(const std::complex<T>& X) { return X.real(); }
template<typename eT> template<typename eT>
skipping to change at line 131 skipping to change at line 133
} }
return eT(0); return eT(0);
} }
template<typename eT> template<typename eT>
inline inline
void void
cblas_gemv cblas_gemv
( (
const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const atlas_CBLAS_LAYOUT layout, const atlas_CBLAS_TRANS TransA,
const int M, const int N, const int M, const int N,
const eT alpha, const eT alpha,
const eT *A, const int lda, const eT *A, const int lda,
const eT *X, const int incX, const eT *X, const int incX,
const eT beta, const eT beta,
eT *Y, const int incY eT *Y, const int incY
) )
{ {
arma_type_check((is_supported_blas_type<eT>::value == false)); arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value) if(is_float<eT>::value)
{ {
typedef float T; typedef float T;
arma_wrapper(cblas_sgemv)(Order, TransA, M, N, (const T)tmp_real(alpha), ( const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY); arma_wrapper(cblas_sgemv)(layout, TransA, M, N, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY);
} }
else else
if(is_double<eT>::value) if(is_double<eT>::value)
{ {
typedef double T; typedef double T;
arma_wrapper(cblas_dgemv)(Order, TransA, M, N, (const T)tmp_real(alpha), ( const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY); arma_wrapper(cblas_dgemv)(layout, TransA, M, N, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY);
} }
else else
if(is_cx_float<eT>::value) if(is_cx_float<eT>::value)
{ {
typedef std::complex<float> T; typedef std::complex<float> T;
arma_wrapper(cblas_cgemv)(Order, TransA, M, N, (const T*)&alpha, (const T* )A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY); arma_wrapper(cblas_cgemv)(layout, TransA, M, N, (const T*)&alpha, (const T *)A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY);
} }
else else
if(is_cx_double<eT>::value) if(is_cx_double<eT>::value)
{ {
typedef std::complex<double> T; typedef std::complex<double> T;
arma_wrapper(cblas_zgemv)(Order, TransA, M, N, (const T*)&alpha, (const T* )A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY); arma_wrapper(cblas_zgemv)(layout, TransA, M, N, (const T*)&alpha, (const T *)A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY);
} }
} }
template<typename eT> template<typename eT>
inline inline
void void
cblas_gemm cblas_gemm
( (
const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const atlas_CBLAS_LAYOUT layout, const atlas_CBLAS_TRANS TransA,
const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const atlas_CBLAS_TRANS TransB, const int M, const int N,
const int K, const eT alpha, const eT *A, const int K, const eT alpha, const eT *A,
const int lda, const eT *B, const int ldb, const int lda, const eT *B, const int ldb,
const eT beta, eT *C, const int ldc const eT beta, eT *C, const int ldc
) )
{ {
arma_type_check((is_supported_blas_type<eT>::value == false)); arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value) if(is_float<eT>::value)
{ {
typedef float T; typedef float T;
arma_wrapper(cblas_sgemm)(Order, TransA, TransB, M, N, K, (const T)tmp_rea l(alpha), (const T*)A, lda, (const T*)B, ldb, (const T)tmp_real(beta), (T*)C, ld c); arma_wrapper(cblas_sgemm)(layout, TransA, TransB, M, N, K, (const T)tmp_re al(alpha), (const T*)A, lda, (const T*)B, ldb, (const T)tmp_real(beta), (T*)C, l dc);
} }
else else
if(is_double<eT>::value) if(is_double<eT>::value)
{ {
typedef double T; typedef double T;
arma_wrapper(cblas_dgemm)(Order, TransA, TransB, M, N, K, (const T)tmp_rea l(alpha), (const T*)A, lda, (const T*)B, ldb, (const T)tmp_real(beta), (T*)C, ld c); arma_wrapper(cblas_dgemm)(layout, TransA, TransB, M, N, K, (const T)tmp_re al(alpha), (const T*)A, lda, (const T*)B, ldb, (const T)tmp_real(beta), (T*)C, l dc);
} }
else else
if(is_cx_float<eT>::value) if(is_cx_float<eT>::value)
{ {
typedef std::complex<float> T; typedef std::complex<float> T;
arma_wrapper(cblas_cgemm)(Order, TransA, TransB, M, N, K, (const T*)&alpha , (const T*)A, lda, (const T*)B, ldb, (const T*)&beta, (T*)C, ldc); arma_wrapper(cblas_cgemm)(layout, TransA, TransB, M, N, K, (const T*)&alph a, (const T*)A, lda, (const T*)B, ldb, (const T*)&beta, (T*)C, ldc);
} }
else else
if(is_cx_double<eT>::value) if(is_cx_double<eT>::value)
{ {
typedef std::complex<double> T; typedef std::complex<double> T;
arma_wrapper(cblas_zgemm)(Order, TransA, TransB, M, N, K, (const T*)&alpha , (const T*)A, lda, (const T*)B, ldb, (const T*)&beta, (T*)C, ldc); arma_wrapper(cblas_zgemm)(layout, TransA, TransB, M, N, K, (const T*)&alph a, (const T*)A, lda, (const T*)B, ldb, (const T*)&beta, (T*)C, ldc);
} }
} }
template<typename eT> template<typename eT>
inline inline
void void
cblas_syrk cblas_syrk
( (
const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_T RANSPOSE Trans, const atlas_CBLAS_LAYOUT layout, const atlas_CBLAS_UPLO Uplo, const atlas_CB LAS_TRANS Trans,
const int N, const int K, const eT alpha, const int N, const int K, const eT alpha,
const eT* A, const int lda, const eT beta, eT* C, const int ldc const eT* A, const int lda, const eT beta, eT* C, const int ldc
) )
{ {
arma_type_check((is_supported_blas_type<eT>::value == false)); arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value) if(is_float<eT>::value)
{ {
typedef float T; typedef float T;
arma_wrapper(cblas_ssyrk)(Order, Uplo, Trans, N, K, (const T)alpha, (const T*)A, lda, (const T)beta, (T*)C, ldc); arma_wrapper(cblas_ssyrk)(layout, Uplo, Trans, N, K, (const T)alpha, (cons t T*)A, lda, (const T)beta, (T*)C, ldc);
} }
else else
if(is_double<eT>::value) if(is_double<eT>::value)
{ {
typedef double T; typedef double T;
arma_wrapper(cblas_dsyrk)(Order, Uplo, Trans, N, K, (const T)alpha, (const T*)A, lda, (const T)beta, (T*)C, ldc); arma_wrapper(cblas_dsyrk)(layout, Uplo, Trans, N, K, (const T)alpha, (cons t T*)A, lda, (const T)beta, (T*)C, ldc);
} }
} }
template<typename T> template<typename T>
inline inline
void void
cblas_herk cblas_herk
( (
const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_T RANSPOSE Trans, const atlas_CBLAS_LAYOUT layout, const atlas_CBLAS_UPLO Uplo, const atlas_CB LAS_TRANS Trans,
const int N, const int K, const T alpha, const int N, const int K, const T alpha,
const std::complex<T>* A, const int lda, const T beta, std::complex<T>* C, c onst int ldc const std::complex<T>* A, const int lda, const T beta, std::complex<T>* C, c onst int ldc
) )
{ {
arma_type_check((is_supported_blas_type<T>::value == false)); arma_type_check((is_supported_blas_type<T>::value == false));
if(is_float<T>::value) if(is_float<T>::value)
{ {
typedef float TT; typedef float TT;
typedef std::complex<float> cx_TT; typedef std::complex<float> cx_TT;
arma_wrapper(cblas_cherk)(Order, Uplo, Trans, N, K, (const TT)alpha, (cons t cx_TT*)A, lda, (const TT)beta, (cx_TT*)C, ldc); arma_wrapper(cblas_cherk)(layout, Uplo, Trans, N, K, (const TT)alpha, (con st cx_TT*)A, lda, (const TT)beta, (cx_TT*)C, ldc);
} }
else else
if(is_double<T>::value) if(is_double<T>::value)
{ {
typedef double TT; typedef double TT;
typedef std::complex<double> cx_TT; typedef std::complex<double> cx_TT;
arma_wrapper(cblas_zherk)(Order, Uplo, Trans, N, K, (const TT)alpha, (cons arma_wrapper(cblas_zherk)(layout, Uplo, Trans, N, K, (const TT)alpha, (con
t cx_TT*)A, lda, (const TT)beta, (cx_TT*)C, ldc); st cx_TT*)A, lda, (const TT)beta, (cx_TT*)C, ldc);
}
}
template<typename eT>
inline
int
clapack_getrf
(
const enum CBLAS_ORDER Order, const int M, const int N,
eT *A, const int lda, int *ipiv
)
{
arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value)
{
typedef float T;
return arma_wrapper(clapack_sgetrf)(Order, M, N, (T*)A, lda, ipiv);
}
else
if(is_double<eT>::value)
{
typedef double T;
return arma_wrapper(clapack_dgetrf)(Order, M, N, (T*)A, lda, ipiv);
}
else
if(is_cx_float<eT>::value)
{
typedef std::complex<float> T;
return arma_wrapper(clapack_cgetrf)(Order, M, N, (T*)A, lda, ipiv);
}
else
if(is_cx_double<eT>::value)
{
typedef std::complex<double> T;
return arma_wrapper(clapack_zgetrf)(Order, M, N, (T*)A, lda, ipiv);
}
return -1;
}
template<typename eT>
inline
int
clapack_getri
(
const enum CBLAS_ORDER Order, const int N, eT *A,
const int lda, const int *ipiv
)
{
arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value)
{
typedef float T;
return arma_wrapper(clapack_sgetri)(Order, N, (T*)A, lda, ipiv);
}
else
if(is_double<eT>::value)
{
typedef double T;
return arma_wrapper(clapack_dgetri)(Order, N, (T*)A, lda, ipiv);
}
else
if(is_cx_float<eT>::value)
{
typedef std::complex<float> T;
return arma_wrapper(clapack_cgetri)(Order, N, (T*)A, lda, ipiv);
}
else
if(is_cx_double<eT>::value)
{
typedef std::complex<double> T;
return arma_wrapper(clapack_zgetri)(Order, N, (T*)A, lda, ipiv);
}
return -1;
}
template<typename eT>
inline
int
clapack_gesv
(
const enum CBLAS_ORDER Order,
const int N, const int NRHS,
eT* A, const int lda, int* ipiv,
eT* B, const int ldb
)
{
arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value)
{
typedef float T;
return arma_wrapper(clapack_sgesv)(Order, N, NRHS, (T*)A, lda, ipiv, (T*)B
, ldb);
}
else
if(is_double<eT>::value)
{
typedef double T;
return arma_wrapper(clapack_dgesv)(Order, N, NRHS, (T*)A, lda, ipiv, (T*)B
, ldb);
}
else
if(is_cx_float<eT>::value)
{
typedef std::complex<float> T;
return arma_wrapper(clapack_cgesv)(Order, N, NRHS, (T*)A, lda, ipiv, (T*)B
, ldb);
}
else
if(is_cx_double<eT>::value)
{
typedef std::complex<double> T;
return arma_wrapper(clapack_zgesv)(Order, N, NRHS, (T*)A, lda, ipiv, (T*)B
, ldb);
}
return -1;
}
template<typename eT>
inline
int
clapack_potrf(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const
int N, eT *A, const int lda)
{
arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value)
{
typedef float T;
return arma_wrapper(clapack_spotrf)(Order, Uplo, N, (T*)A, lda);
}
else
if(is_double<eT>::value)
{
typedef double T;
return arma_wrapper(clapack_dpotrf)(Order, Uplo, N, (T*)A, lda);
}
else
if(is_cx_float<eT>::value)
{
typedef std::complex<float> T;
return arma_wrapper(clapack_cpotrf)(Order, Uplo, N, (T*)A, lda);
}
else
if(is_cx_double<eT>::value)
{
typedef std::complex<double> T;
return arma_wrapper(clapack_zpotrf)(Order, Uplo, N, (T*)A, lda);
}
return -1;
}
template<typename eT>
inline
int
clapack_potri(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const
int N, eT *A, const int lda)
{
arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value)
{
typedef float T;
return arma_wrapper(clapack_spotri)(Order, Uplo, N, (T*)A, lda);
} }
else
if(is_double<eT>::value)
{
typedef double T;
return arma_wrapper(clapack_dpotri)(Order, Uplo, N, (T*)A, lda);
}
else
if(is_cx_float<eT>::value)
{
typedef std::complex<float> T;
return arma_wrapper(clapack_cpotri)(Order, Uplo, N, (T*)A, lda);
}
else
if(is_cx_double<eT>::value)
{
typedef std::complex<double> T;
return arma_wrapper(clapack_zpotri)(Order, Uplo, N, (T*)A, lda);
}
return -1;
} }
template<typename eT>
inline
int
clapack_posv(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const i
nt N, const int NRHS, eT *A, const int lda, eT *B, const int ldb)
{
arma_type_check((is_supported_blas_type<eT>::value == false));
if(is_float<eT>::value)
{
typedef float T;
return arma_wrapper(clapack_sposv)(Order, Uplo, N, NRHS, (T*)A, lda, (T*)B
, ldb);
}
else
if(is_double<eT>::value)
{
typedef double T;
return arma_wrapper(clapack_dposv)(Order, Uplo, N, NRHS, (T*)A, lda, (T*)B
, ldb);
}
else
if(is_cx_float<eT>::value)
{
typedef std::complex<float> T;
return arma_wrapper(clapack_cposv)(Order, Uplo, N, NRHS, (T*)A, lda, (T*)B
, ldb);
}
else
if(is_cx_double<eT>::value)
{
typedef std::complex<double> T;
return arma_wrapper(clapack_zposv)(Order, Uplo, N, NRHS, (T*)A, lda, (T*)B
, ldb);
}
return -1;
}
} }
#endif #endif
 End of changes. 20 change blocks. 
249 lines changed or deleted 22 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)