mirror/eigen
2
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2024-12-21 07:19:46 +08:00
Code Issues Packages Projects Releases Wiki Activity
ca85a1f6c5
eigen/blas/level3_impl.h

571 lines
27 KiB
C
Raw Normal View History

add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
compilation fix
2010-10-09 04:51:10 +08:00
// Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
//
// Eigen 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.
//
// Alternatively, you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Eigen 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 or the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>.
#include "common.h"
int EIGEN_BLAS_FUNC(gemm)(char *opa, char *opb, int *m, int *n, int *k, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pb, int *ldb, RealScalar *pbeta, RealScalar *pc, int *ldc)
{
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
// std::cerr << "in gemm " << *opa << " " << *opb << " " << *m << " " << *n << " " << *k << " " << *lda << " " << *ldb << " " << *ldc << " " << *palpha << " " << *pbeta << "\n";
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
typedef void (*functype)(DenseIndex, DenseIndex, DenseIndex, const Scalar *, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, Scalar, ei_level3_blocking<Scalar,Scalar>&, Eigen::GemmParallelInfo<DenseIndex>*);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
static functype func[12];
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
static bool init = false;
if(!init)
{
for(int k=0; k<12; ++k)
func[k] = 0;
compilation fix
2010-10-09 04:51:10 +08:00
func[NOTR | (NOTR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,ColMajor,false,Scalar,ColMajor,false,ColMajor>::run);
func[TR | (NOTR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,ColMajor,false,ColMajor>::run);
func[ADJ | (NOTR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,ColMajor,false,ColMajor>::run);
func[NOTR | (TR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,ColMajor,false,Scalar,RowMajor,false,ColMajor>::run);
func[TR | (TR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,RowMajor,false,ColMajor>::run);
func[ADJ | (TR << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,RowMajor,false,ColMajor>::run);
func[NOTR | (ADJ << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,ColMajor,false,Scalar,RowMajor,Conj, ColMajor>::run);
func[TR | (ADJ << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,false,Scalar,RowMajor,Conj, ColMajor>::run);
func[ADJ | (ADJ << 2)] = (ei_general_matrix_matrix_product<DenseIndex,Scalar,RowMajor,Conj, Scalar,RowMajor,Conj, ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
init = true;
}
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* b = reinterpret_cast<Scalar*>(pb);
Scalar* c = reinterpret_cast<Scalar*>(pc);
Scalar alpha = *reinterpret_cast<Scalar*>(palpha);
Scalar beta = *reinterpret_cast<Scalar*>(pbeta);
int code = OP(*opa) | (OP(*opb) << 2);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
if(code>=12 || func[code]==0 || (*m<0) || (*n<0) || (*k<0))
{
int info = 1;
xerbla_("GEMM", &info, 4);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
return 0;
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
}
if(beta!=Scalar(1))
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
{
fix a couple a issue with blas (new TRMM api, and enforece column major)
2010-07-17 05:30:06 +08:00
if(beta==Scalar(0)) matrix(c, *m, *n, *ldc).setZero();
else matrix(c, *m, *n, *ldc) *= beta;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
}
ei_gemm_blocking_space<ColMajor,Scalar,Scalar,Dynamic,Dynamic,Dynamic> blocking(*m,*n,*k);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[code](*m, *n, *k, a, *lda, b, *ldb, c, *ldc, alpha, blocking, 0);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
return 0;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
}
int EIGEN_BLAS_FUNC(trsm)(char *side, char *uplo, char *opa, char *diag, int *m, int *n, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pb, int *ldb)
{
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
// std::cerr << "in trsm " << *side << " " << *uplo << " " << *opa << " " << *diag << " " << *m << "," << *n << " " << *palpha << " " << *lda << " " << *ldb<< "\n";
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
typedef void (*functype)(DenseIndex, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
static functype func[32];
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
static bool init = false;
if(!init)
{
for(int k=0; k<32; ++k)
func[k] = 0;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|0, false,ColMajor,ColMajor>::run);
func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, false,RowMajor,ColMajor>::run);
func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, Conj, RowMajor,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, false,ColMajor,ColMajor>::run);
func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, false,RowMajor,ColMajor>::run);
func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, Conj, RowMajor,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|0, false,ColMajor,ColMajor>::run);
func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|0, false,RowMajor,ColMajor>::run);
func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|0, Conj, RowMajor,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|0, false,ColMajor,ColMajor>::run);
func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, false,RowMajor,ColMajor>::run);
func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|0, Conj, RowMajor,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,false,ColMajor,ColMajor>::run);
func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,false,RowMajor,ColMajor>::run);
func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,Conj, RowMajor,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,false,ColMajor,ColMajor>::run);
func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,false,RowMajor,ColMajor>::run);
func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,Conj, RowMajor,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Lower|UnitDiag,false,ColMajor,ColMajor>::run);
func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,false,RowMajor,ColMajor>::run);
func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheLeft, Upper|UnitDiag,Conj, RowMajor,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Lower|UnitDiag,false,ColMajor,ColMajor>::run);
func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,false,RowMajor,ColMajor>::run);
func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_triangular_solve_matrix<Scalar,DenseIndex,OnTheRight,Upper|UnitDiag,Conj, RowMajor,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
init = true;
}
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* b = reinterpret_cast<Scalar*>(pb);
Scalar alpha = *reinterpret_cast<Scalar*>(palpha);
int code = OP(*opa) | (SIDE(*side) << 2) | (UPLO(*uplo) << 3) | (DIAG(*diag) << 4);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
if(code>=32 || func[code]==0 || *m<0 || *n <0)
{
int info=1;
xerbla_("TRSM",&info,4);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
return 0;
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
if(SIDE(*side)==LEFT)
func[code](*m, *n, a, *lda, b, *ldb);
else
func[code](*n, *m, a, *lda, b, *ldb);
if(alpha!=Scalar(1))
matrix(b,*m,*n,*ldb) *= alpha;
return 0;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
}
// b = alpha*op(a)*b for side = 'L'or'l'
// b = alpha*b*op(a) for side = 'R'or'r'
int EIGEN_BLAS_FUNC(trmm)(char *side, char *uplo, char *opa, char *diag, int *m, int *n, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pb, int *ldb)
{
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
// std::cerr << "in trmm " << *side << " " << *uplo << " " << *opa << " " << *diag << " " << *m << " " << *n << " " << *lda << " " << *ldb << " " << *palpha << "\n";
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
typedef void (*functype)(DenseIndex, DenseIndex, DenseIndex, const Scalar *, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, Scalar);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
static functype func[32];
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
static bool init = false;
if(!init)
{
for(int k=0; k<32; ++k)
func[k] = 0;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, true, ColMajor,false,ColMajor,false,ColMajor>::run);
func[TR | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, RowMajor,false,ColMajor,false,ColMajor>::run);
func[ADJ | (LEFT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,ColMajor,false,ColMajor>::run);
func[TR | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,RowMajor,false,ColMajor>::run);
func[ADJ | (RIGHT << 2) | (UP << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,RowMajor,Conj, ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, true, ColMajor,false,ColMajor,false,ColMajor>::run);
func[TR | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, true, RowMajor,false,ColMajor,false,ColMajor>::run);
func[ADJ | (LEFT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, true, RowMajor,Conj, ColMajor,false,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|0, false,ColMajor,false,ColMajor,false,ColMajor>::run);
func[TR | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,RowMajor,false,ColMajor>::run);
func[ADJ | (RIGHT << 2) | (LO << 3) | (NUNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|0, false,ColMajor,false,RowMajor,Conj, ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, ColMajor,false,ColMajor,false,ColMajor>::run);
func[TR | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, RowMajor,false,ColMajor,false,ColMajor>::run);
func[ADJ | (LEFT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, RowMajor,Conj, ColMajor,false,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,ColMajor,false,ColMajor>::run);
func[TR | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,RowMajor,false,ColMajor>::run);
func[ADJ | (RIGHT << 2) | (UP << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,RowMajor,Conj, ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,true, ColMajor,false,ColMajor,false,ColMajor>::run);
func[TR | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, RowMajor,false,ColMajor,false,ColMajor>::run);
func[ADJ | (LEFT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,true, RowMajor,Conj, ColMajor,false,ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Lower|UnitDiag,false,ColMajor,false,ColMajor,false,ColMajor>::run);
func[TR | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,RowMajor,false,ColMajor>::run);
func[ADJ | (RIGHT << 2) | (LO << 3) | (UNIT << 4)] = (ei_product_triangular_matrix_matrix<Scalar,DenseIndex,Upper|UnitDiag,false,ColMajor,false,RowMajor,Conj, ColMajor>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
init = true;
}
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* b = reinterpret_cast<Scalar*>(pb);
Scalar alpha = *reinterpret_cast<Scalar*>(palpha);
int code = OP(*opa) | (SIDE(*side) << 2) | (UPLO(*uplo) << 3) | (DIAG(*diag) << 4);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
if(code>=32 || func[code]==0 || *m<0 || *n <0)
{
int info=1;
xerbla_("TRMM",&info,4);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
return 0;
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
}
fix a couple a issue with blas (new TRMM api, and enforece column major)
2010-07-17 05:30:06 +08:00
if(*m==0 || *n==0)
return 1;
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
// FIXME find a way to avoid this copy
fix a couple a issue with blas (new TRMM api, and enforece column major)
2010-07-17 05:30:06 +08:00
Matrix<Scalar,Dynamic,Dynamic,ColMajor> tmp = matrix(b,*m,*n,*ldb);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
matrix(b,*m,*n,*ldb).setZero();
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
if(SIDE(*side)==LEFT)
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[code](*m, *n, *m, a, *lda, tmp.data(), tmp.outerStride(), b, *ldb, alpha);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
else
fix a couple a issue with blas (new TRMM api, and enforece column major)
2010-07-17 05:30:06 +08:00
func[code](*m, *n, *n, tmp.data(), tmp.outerStride(), a, *lda, b, *ldb, alpha);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
return 1;
}
// c = alpha*a*b + beta*c for side = 'L'or'l'
// c = alpha*b*a + beta*c for side = 'R'or'r
int EIGEN_BLAS_FUNC(symm)(char *side, char *uplo, int *m, int *n, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pb, int *ldb, RealScalar *pbeta, RealScalar *pc, int *ldc)
{
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
// std::cerr << "in symm " << *side << " " << *uplo << " " << *m << "x" << *n << " lda:" << *lda << " ldb:" << *ldb << " ldc:" << *ldc << " alpha:" << *palpha << " beta:" << *pbeta << "\n";
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* b = reinterpret_cast<Scalar*>(pb);
Scalar* c = reinterpret_cast<Scalar*>(pc);
Scalar alpha = *reinterpret_cast<Scalar*>(palpha);
Scalar beta = *reinterpret_cast<Scalar*>(pbeta);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
if(*m<0 || *n<0)
{
int info=1;
xerbla_("SYMM",&info,4);
return 0;
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
if(beta!=Scalar(1))
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
{
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
if(beta==Scalar(0)) matrix(c, *m, *n, *ldc).setZero();
else matrix(c, *m, *n, *ldc) *= beta;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
if(*m==0 || *n==0)
{
return 1;
}
#if ISCOMPLEX
// FIXME add support for symmetric complex matrix
int size = (SIDE(*side)==LEFT) ? (*m) : (*n);
Matrix<Scalar,Dynamic,Dynamic,ColMajor> matA(size,size);
if(UPLO(*uplo)==UP)
{
matA.triangularView<Upper>() = matrix(a,size,size,*lda);
matA.triangularView<Lower>() = matrix(a,size,size,*lda).transpose();
}
else if(UPLO(*uplo)==LO)
{
matA.triangularView<Lower>() = matrix(a,size,size,*lda);
matA.triangularView<Upper>() = matrix(a,size,size,*lda).transpose();
}
if(SIDE(*side)==LEFT)
matrix(c, *m, *n, *ldc) += alpha * matA * matrix(b, *m, *n, *ldb);
else if(SIDE(*side)==RIGHT)
matrix(c, *m, *n, *ldc) += alpha * matrix(b, *m, *n, *ldb) * matA;
#else
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
if(SIDE(*side)==LEFT)
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
if(UPLO(*uplo)==UP) ei_product_selfadjoint_matrix<Scalar, DenseIndex, RowMajor,true,false, ColMajor,false,false, ColMajor>::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha);
else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix<Scalar, DenseIndex, ColMajor,true,false, ColMajor,false,false, ColMajor>::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha);
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
else return 0;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
else if(SIDE(*side)==RIGHT)
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
if(UPLO(*uplo)==UP) ei_product_selfadjoint_matrix<Scalar, DenseIndex, ColMajor,false,false, RowMajor,true,false, ColMajor>::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha);
else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix<Scalar, DenseIndex, ColMajor,false,false, ColMajor,true,false, ColMajor>::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha);
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
else return 0;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
else
return 0;
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
#endif
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
return 0;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
}
// c = alpha*a*a' + beta*c for op = 'N'or'n'
// c = alpha*a'*a + beta*c for op = 'T'or't','C'or'c'
int EIGEN_BLAS_FUNC(syrk)(char *uplo, char *op, int *n, int *k, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pbeta, RealScalar *pc, int *ldc)
{
blas: fix SYRK
2010-03-02 16:37:10 +08:00
// std::cerr << "in syrk " << *uplo << " " << *op << " " << *n << " " << *k << " " << *palpha << " " << *lda << " " << *pbeta << " " << *ldc << "\n";
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
typedef void (*functype)(DenseIndex, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, Scalar);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
static functype func[8];
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
static bool init = false;
if(!init)
{
for(int k=0; k<8; ++k)
func[k] = 0;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (UP << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Upper>::run);
func[TR | (UP << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run);
func[ADJ | (UP << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Lower>::run);
func[TR | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::run);
func[ADJ | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
init = true;
}
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* c = reinterpret_cast<Scalar*>(pc);
Scalar alpha = *reinterpret_cast<Scalar*>(palpha);
Scalar beta = *reinterpret_cast<Scalar*>(pbeta);
int code = OP(*op) | (UPLO(*uplo) << 2);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
if(code>=8 || func[code]==0 || *n<0 || *k<0)
{
int info=1;
xerbla_("SYRK",&info,4);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
return 0;
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
if(beta!=Scalar(1))
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
{
blas: fix SYRK
2010-03-02 16:37:10 +08:00
if(UPLO(*uplo)==UP) matrix(c, *n, *n, *ldc).triangularView<Upper>() *= beta;
else matrix(c, *n, *n, *ldc).triangularView<Lower>() *= beta;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
#if ISCOMPLEX
// FIXME add support for symmetric complex matrix
if(UPLO(*uplo)==UP)
{
if(OP(*op)==NOTR)
matrix(c, *n, *n, *ldc).triangularView<Upper>() += alpha * matrix(a,*n,*k,*lda) * matrix(a,*n,*k,*lda).transpose();
else
matrix(c, *n, *n, *ldc).triangularView<Upper>() += alpha * matrix(a,*k,*n,*lda).transpose() * matrix(a,*k,*n,*lda);
}
else
{
if(OP(*op)==NOTR)
matrix(c, *n, *n, *ldc).triangularView<Lower>() += alpha * matrix(a,*n,*k,*lda) * matrix(a,*n,*k,*lda).transpose();
else
matrix(c, *n, *n, *ldc).triangularView<Lower>() += alpha * matrix(a,*k,*n,*lda).transpose() * matrix(a,*k,*n,*lda);
}
#else
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
func[code](*n, *k, a, *lda, c, *ldc, alpha);
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
#endif
blas: fix SYRK
2010-03-02 16:37:10 +08:00
return 0;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
}
// c = alpha*a*b' + alpha*b*a' + beta*c for op = 'N'or'n'
// c = alpha*a'*b + alpha*b'*a + beta*c for op = 'T'or't'
int EIGEN_BLAS_FUNC(syr2k)(char *uplo, char *op, int *n, int *k, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pb, int *ldb, RealScalar *pbeta, RealScalar *pc, int *ldc)
{
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* b = reinterpret_cast<Scalar*>(pb);
Scalar* c = reinterpret_cast<Scalar*>(pc);
Scalar alpha = *reinterpret_cast<Scalar*>(palpha);
Scalar beta = *reinterpret_cast<Scalar*>(pbeta);
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
if(*n<=0 || *k<0)
{
return 0;
}
if(beta!=Scalar(1))
{
if(UPLO(*uplo)==UP) matrix(c, *n, *n, *ldc).triangularView<Upper>() *= beta;
else matrix(c, *n, *n, *ldc).triangularView<Lower>() *= beta;
}
if(*k==0)
return 1;
if(OP(*op)==NOTR)
{
if(UPLO(*uplo)==UP)
{
matrix(c, *n, *n, *ldc).triangularView<Upper>()
+= alpha *matrix(a, *n, *k, *lda)*matrix(b, *n, *k, *ldb).transpose()
+ alpha*matrix(b, *n, *k, *ldb)*matrix(a, *n, *k, *lda).transpose();
}
else if(UPLO(*uplo)==LO)
matrix(c, *n, *n, *ldc).triangularView<Lower>()
+= alpha*matrix(a, *n, *k, *lda)*matrix(b, *n, *k, *ldb).transpose()
+ alpha*matrix(b, *n, *k, *ldb)*matrix(a, *n, *k, *lda).transpose();
}
else if(OP(*op)==TR || OP(*op)==ADJ)
{
if(UPLO(*uplo)==UP)
matrix(c, *n, *n, *ldc).triangularView<Upper>()
+= alpha*matrix(a, *k, *n, *lda).transpose()*matrix(b, *k, *n, *ldb)
+ alpha*matrix(b, *k, *n, *ldb).transpose()*matrix(a, *k, *n, *lda);
else if(UPLO(*uplo)==LO)
matrix(c, *n, *n, *ldc).triangularView<Lower>()
+= alpha*matrix(a, *k, *n, *lda).transpose()*matrix(b, *k, *n, *ldb)
+ alpha*matrix(b, *k, *n, *ldb).transpose()*matrix(a, *k, *n, *lda);
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
return 0;
}
#if ISCOMPLEX
// c = alpha*a*b + beta*c for side = 'L'or'l'
// c = alpha*b*a + beta*c for side = 'R'or'r
int EIGEN_BLAS_FUNC(hemm)(char *side, char *uplo, int *m, int *n, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pb, int *ldb, RealScalar *pbeta, RealScalar *pc, int *ldc)
{
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* b = reinterpret_cast<Scalar*>(pb);
Scalar* c = reinterpret_cast<Scalar*>(pc);
Scalar alpha = *reinterpret_cast<Scalar*>(palpha);
Scalar beta = *reinterpret_cast<Scalar*>(pbeta);
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
// std::cerr << "in hemm " << *side << " " << *uplo << " " << *m << " " << *n << " " << alpha << " " << *lda << " " << beta << " " << *ldc << "\n";
if(*m<0 || *n<0)
{
return 0;
}
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
if(beta==Scalar(0))
matrix(c, *m, *n, *ldc).setZero();
else if(beta!=Scalar(1))
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
matrix(c, *m, *n, *ldc) *= beta;
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
if(*m==0 || *n==0)
{
return 1;
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
if(SIDE(*side)==LEFT)
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
{
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
if(UPLO(*uplo)==UP) ei_product_selfadjoint_matrix<Scalar,DenseIndex,RowMajor,true,Conj, ColMajor,false,false, ColMajor>
::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha);
else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,true,false, ColMajor,false,false, ColMajor>
::run(*m, *n, a, *lda, b, *ldb, c, *ldc, alpha);
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
else return 0;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
else if(SIDE(*side)==RIGHT)
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
{
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
if(UPLO(*uplo)==UP) matrix(c,*m,*n,*ldc) += alpha * matrix(b,*m,*n,*ldb) * matrix(a,*n,*n,*lda).selfadjointView<Upper>();/*ei_product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,false,false, RowMajor,true,Conj, ColMajor>
::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha);*/
else if(UPLO(*uplo)==LO) ei_product_selfadjoint_matrix<Scalar,DenseIndex,ColMajor,false,false, ColMajor,true,false, ColMajor>
::run(*m, *n, b, *ldb, a, *lda, c, *ldc, alpha);
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
else return 0;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
else
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
{
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
return 0;
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
return 0;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
}
// c = alpha*a*conj(a') + beta*c for op = 'N'or'n'
// c = alpha*conj(a')*a + beta*c for op = 'C'or'c'
int EIGEN_BLAS_FUNC(herk)(char *uplo, char *op, int *n, int *k, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pbeta, RealScalar *pc, int *ldc)
{
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
typedef void (*functype)(DenseIndex, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, Scalar);
blas interface: fix compilation, fix GEMM, SYMM, TRMM, and TRSM, i,e., they all pass the blas test suite. More to come
2010-03-02 02:06:07 +08:00
static functype func[8];
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
static bool init = false;
if(!init)
{
for(int k=0; k<8; ++k)
func[k] = 0;
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (UP << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Upper>::run);
func[ADJ | (UP << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Upper>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix compilation of blas lib
2010-07-17 04:27:24 +08:00
func[NOTR | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,ColMajor,ColMajor,true, Lower>::run);
func[ADJ | (LO << 2)] = (ei_selfadjoint_product<Scalar,DenseIndex,RowMajor,ColMajor,false,Lower>::run);
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
init = true;
}
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* c = reinterpret_cast<Scalar*>(pc);
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
RealScalar alpha = *palpha;
RealScalar beta = *pbeta;
// std::cerr << "in herk " << *uplo << " " << *op << " " << *n << " " << *k << " " << alpha << " " << *lda << " " << beta << " " << *ldc << "\n";
if(*n<0 || *k<0)
{
return 0;
}
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
int code = OP(*op) | (UPLO(*uplo) << 2);
if(code>=8 || func[code]==0)
return 0;
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
if(beta!=RealScalar(1))
{
if(UPLO(*uplo)==UP) matrix(c, *n, *n, *ldc).triangularView<StrictlyUpper>() *= beta;
else matrix(c, *n, *n, *ldc).triangularView<StrictlyLower>() *= beta;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
matrix(c, *n, *n, *ldc).diagonal().real() *= beta;
matrix(c, *n, *n, *ldc).diagonal().imag().setZero();
}
if(*k>0 && alpha!=RealScalar(0))
{
func[code](*n, *k, a, *lda, c, *ldc, alpha);
matrix(c, *n, *n, *ldc).diagonal().imag().setZero();
}
return 0;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
}
// c = alpha*a*conj(b') + conj(alpha)*b*conj(a') + beta*c, for op = 'N'or'n'
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
// c = alpha*conj(a')*b + conj(alpha)*conj(b')*a + beta*c, for op = 'C'or'c'
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
int EIGEN_BLAS_FUNC(her2k)(char *uplo, char *op, int *n, int *k, RealScalar *palpha, RealScalar *pa, int *lda, RealScalar *pb, int *ldb, RealScalar *pbeta, RealScalar *pc, int *ldc)
{
Scalar* a = reinterpret_cast<Scalar*>(pa);
Scalar* b = reinterpret_cast<Scalar*>(pb);
Scalar* c = reinterpret_cast<Scalar*>(pc);
Scalar alpha = *reinterpret_cast<Scalar*>(palpha);
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
RealScalar beta = *pbeta;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
if(*n<=0 || *k<0)
blas: fix HEMM and HERK
2010-03-02 19:44:40 +08:00
{
return 0;
}
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
if(beta!=RealScalar(1))
{
if(UPLO(*uplo)==UP) matrix(c, *n, *n, *ldc).triangularView<StrictlyUpper>() *= beta;
else matrix(c, *n, *n, *ldc).triangularView<StrictlyLower>() *= beta;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
fix level3 blas: it now passes all computational tests
2010-07-17 17:59:09 +08:00
matrix(c, *n, *n, *ldc).diagonal().real() *= beta;
matrix(c, *n, *n, *ldc).diagonal().imag().setZero();
}
else if(*k>0 && alpha!=Scalar(0))
matrix(c, *n, *n, *ldc).diagonal().imag().setZero();
if(*k==0)
return 1;
if(OP(*op)==NOTR)
{
if(UPLO(*uplo)==UP)
{
matrix(c, *n, *n, *ldc).triangularView<Upper>()
+= alpha *matrix(a, *n, *k, *lda)*matrix(b, *n, *k, *ldb).adjoint()
+ ei_conj(alpha)*matrix(b, *n, *k, *ldb)*matrix(a, *n, *k, *lda).adjoint();
}
else if(UPLO(*uplo)==LO)
matrix(c, *n, *n, *ldc).triangularView<Lower>()
+= alpha*matrix(a, *n, *k, *lda)*matrix(b, *n, *k, *ldb).adjoint()
+ ei_conj(alpha)*matrix(b, *n, *k, *ldb)*matrix(a, *n, *k, *lda).adjoint();
}
else if(OP(*op)==ADJ)
{
if(UPLO(*uplo)==UP)
matrix(c, *n, *n, *ldc).triangularView<Upper>()
+= alpha*matrix(a, *k, *n, *lda).adjoint()*matrix(b, *k, *n, *ldb)
+ ei_conj(alpha)*matrix(b, *k, *n, *ldb).adjoint()*matrix(a, *k, *n, *lda);
else if(UPLO(*uplo)==LO)
matrix(c, *n, *n, *ldc).triangularView<Lower>()
+= alpha*matrix(a, *k, *n, *lda).adjoint()*matrix(b, *k, *n, *ldb)
+ ei_conj(alpha)*matrix(b, *k, *n, *ldb).adjoint()*matrix(a, *k, *n, *lda);
}
return 1;
add a wip blas library built on top of Eigen. TODO: - write extentive unit tests (maybe this already exist in other projects) - the level2 functions still have to be implemented
2009-09-25 19:08:39 +08:00
}
#endif // ISCOMPLEX
Reference in New Issue Copy Permalink