blas_2.cxx

Multivac 的Level set包

    cblas_ctpmv(CblasRowMajor, CblasLower, TransA, DiagA,
		A.GetN(), reinterpret_cast<const void*>(A.GetData()),
		reinterpret_cast<void*>(X.GetData()), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1>
  void
  Mlt(const enum CBLAS_TRANSPOSE TransA,
      const enum CBLAS_DIAG DiagA,
      const Matrix<complex<double>, Prop0, RowLoTriangPacked, Allocator0>& A,
      Vector<complex<double>, Vect_Full, Allocator1>& X)
  {
    cblas_ztpmv(CblasRowMajor, CblasLower, TransA, DiagA,
		A.GetN(), reinterpret_cast<const void*>(A.GetData()),
		reinterpret_cast<void*>(X.GetData()), 1);
  }


  // MLT //
  /////////



  ////////////
  // MLTADD //


  // General //

  /*** ColMajor and NoTrans ***/


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const float alpha,
	      const Matrix<float, Prop0, ColMajor, Allocator0>& A,
	      const Vector<float, Vect_Full, Allocator1>& X,
	      const float beta,
	      Vector<float, Vect_Full, Allocator2>& Y)
  {
    cblas_sgemv(CblasColMajor, CblasNoTrans,
		A.GetM(), A.GetN(), alpha, A.GetData(), A.GetM(),
		X.GetData(), 1, beta, Y.GetData(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const double alpha,
	      const Matrix<double, Prop0, ColMajor, Allocator0>& A,
	      const Vector<double, Vect_Full, Allocator1>& X,
	      const double beta,
	      Vector<double, Vect_Full, Allocator2>& Y)
  {
    cblas_dgemv(CblasColMajor, CblasNoTrans,
		A.GetM(), A.GetN(), alpha, A.GetData(), A.GetM(),
		X.GetData(), 1, beta, Y.GetData(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<float> alpha,
	      const Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
	      const Vector<complex<float>, Vect_Full, Allocator1>& X,
	      const complex<float> beta,
	      Vector<complex<float>, Vect_Full, Allocator2>& Y)
  {
    cblas_cgemv(CblasColMajor, CblasNoTrans,
		A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
		reinterpret_cast<const void*>(A.GetData()), A.GetM(),
		reinterpret_cast<const void*>(X.GetData()), 1,
		reinterpret_cast<const void*>(&beta),
		reinterpret_cast<void*>(Y.GetData()), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<double> alpha,
	      const Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
	      const Vector<complex<double>, Vect_Full, Allocator1>& X,
	      const complex<double> beta,
	      Vector<complex<double>, Vect_Full, Allocator2>& Y)
  {
    cblas_zgemv(CblasColMajor, CblasNoTrans,
		A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
		reinterpret_cast<const void*>(A.GetData()), A.GetM(),
		reinterpret_cast<const void*>(X.GetData()), 1,
		reinterpret_cast<const void*>(&beta),
		reinterpret_cast<void*>(Y.GetData()), 1);
  }


  /*** ColMajor and TransA ***/


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const float alpha,
	      const enum CBLAS_TRANSPOSE TransA,
	      const Matrix<float, Prop0, ColMajor, Allocator0>& A,
	      const Vector<float, Vect_Full, Allocator1>& X,
	      const float beta,
	      Vector<float, Vect_Full, Allocator2>& Y)
  {
    cblas_sgemv(CblasColMajor, TransA,
		A.GetM(), A.GetN(), alpha, A.GetData(), A.GetM(),
		X.GetData(), 1, beta, Y.GetData(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const double alpha,
	      const enum CBLAS_TRANSPOSE TransA,
	      const Matrix<double, Prop0, ColMajor, Allocator0>& A,
	      const Vector<double, Vect_Full, Allocator1>& X,
	      const double beta,
	      Vector<double, Vect_Full, Allocator2>& Y)
  {
    cblas_dgemv(CblasColMajor, TransA,
		A.GetM(), A.GetN(), alpha, A.GetData(), A.GetM(),
		X.GetData(), 1, beta, Y.GetData(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<float> alpha,
	      const enum CBLAS_TRANSPOSE TransA,
	      const Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
	      const Vector<complex<float>, Vect_Full, Allocator1>& X,
	      const complex<float> beta,
	      Vector<complex<float>, Vect_Full, Allocator2>& Y)
  {
    cblas_cgemv(CblasColMajor, TransA,
		A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
		reinterpret_cast<const void*>(A.GetData()), A.GetM(),
		reinterpret_cast<const void*>(X.GetData()), 1,
		reinterpret_cast<const void*>(&beta),
		reinterpret_cast<void*>(Y.GetData()), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<double> alpha,
	      const enum CBLAS_TRANSPOSE TransA,
	      const Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
	      const Vector<complex<double>, Vect_Full, Allocator1>& X,
	      const complex<double> beta,
	      Vector<complex<double>, Vect_Full, Allocator2>& Y)
  {
    cblas_zgemv(CblasColMajor, TransA,
		A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
		reinterpret_cast<const void*>(A.GetData()), A.GetM(),
		reinterpret_cast<const void*>(X.GetData()), 1,
		reinterpret_cast<const void*>(&beta),
		reinterpret_cast<void*>(Y.GetData()), 1);
  }


  /*** RowMajor and NoTrans ***/


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const float alpha,
	      const Matrix<float, Prop0, RowMajor, Allocator0>& A,
	      const Vector<float, Vect_Full, Allocator1>& X,
	      const float beta,
	      Vector<float, Vect_Full, Allocator2>& Y)
  {
    cblas_sgemv(CblasRowMajor, CblasNoTrans,
		A.GetM(), A.GetN(), alpha, A.GetData(), A.GetM(),
		X.GetData(), 1, beta, Y.GetData(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const double alpha,
	      const Matrix<double, Prop0, RowMajor, Allocator0>& A,
	      const Vector<double, Vect_Full, Allocator1>& X,
	      const double beta,
	      Vector<double, Vect_Full, Allocator2>& Y)
  {
    cblas_dgemv(CblasRowMajor, CblasNoTrans,
		A.GetM(), A.GetN(), alpha, A.GetData(), A.GetM(),
		X.GetData(), 1, beta, Y.GetData(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<float> alpha,
	      const Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
	      const Vector<complex<float>, Vect_Full, Allocator1>& X,
	      const complex<float> beta,
	      Vector<complex<float>, Vect_Full, Allocator2>& Y)
  {
    cblas_cgemv(CblasRowMajor, CblasNoTrans,
		A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
		reinterpret_cast<const void*>(A.GetData()), A.GetM(),
		reinterpret_cast<const void*>(X.GetData()), 1,
		reinterpret_cast<const void*>(&beta),
		reinterpret_cast<void*>(Y.GetData()), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<double> alpha,
	      const Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
	      const Vector<complex<double>, Vect_Full, Allocator1>& X,
	      const complex<double> beta,
	      Vector<complex<double>, Vect_Full, Allocator2>& Y)
  {
    cblas_zgemv(CblasRowMajor, CblasNoTrans,
		A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
		reinterpret_cast<const void*>(A.GetData()), A.GetM(),
		reinterpret_cast<const void*>(X.GetData()), 1,
		reinterpret_cast<const void*>(&beta),
		reinterpret_cast<void*>(Y.GetData()), 1);
  }


  /*** RowMajor and TransA ***/


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const float alpha,
	      const enum CBLAS_TRANSPOSE TransA,
	      const Matrix<float, Prop0, RowMajor, Allocator0>& A,
	      const Vector<float, Vect_Full, Allocator1>& X,
	      const float beta,
	      Vector<float, Vect_Full, Allocator2>& Y)
  {
    cblas_sgemv(CblasRowMajor, TransA,
		A.GetM(), A.GetN(), alpha, A.GetData(), A.GetM(),
		X.GetData(), 1, beta, Y.GetData(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const double alpha,
	      const enum CBLAS_TRANSPOSE TransA,
	      const Matrix<double, Prop0, RowMajor, Allocator0>& A,
	      const Vector<double, Vect_Full, Allocator1>& X,
	      const double beta,
	      Vector<double, Vect_Full, Allocator2>& Y)
  {
    cblas_dgemv(CblasRowMajor, TransA,
		A.GetM(), A.GetN(), alpha, A.GetData(), A.GetM(),
		X.GetData(), 1, beta, Y.GetData(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<float> alpha,
	      const enum CBLAS_TRANSPOSE TransA,
	      const Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
	      const Vector<complex<float>, Vect_Full, Allocator1>& X,
	      const complex<float> beta,
	      Vector<complex<float>, Vect_Full, Allocator2>& Y)
  {
    cblas_cgemv(CblasRowMajor, TransA,
		A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
		reinterpret_cast<const void*>(A.GetData()), A.GetM(),
		reinterpret_cast<const void*>(X.GetData()), 1,
		reinterpret_cast<const void*>(&beta),
		reinterpret_cast<void*>(Y.GetData()), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<double> alpha,
	      const enum CBLAS_TRANSPOSE TransA,
	      const Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
	      const Vector<complex<double>, Vect_Full, Allocator1>& X,
	      const complex<double> beta,
	      Vector<complex<double>, Vect_Full, Allocator2>& Y)
  {
    cblas_zgemv(CblasRowMajor, TransA,
		A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
		reinterpret_cast<const void*>(A.GetData()), A.GetM(),
		reinterpret_cast<const void*>(X.GetData()), 1,
		reinterpret_cast<const void*>(&beta),
		reinterpret_cast<void*>(Y.GetData()), 1);
  }


  // Hermitian //

  /*** ColHerm and Upper ***/


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<float> alpha,
	      const Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
	      const Vector<complex<float>, Vect_Full, Allocator1>& X,
	      const complex<float> beta,
	      Vector<complex<float>, Vect_Full, Allocator2>& Y)
  {
    cblas_chemv(CblasColMajor, CblasUpper,
		A.GetM(), reinterpret_cast<const void*>(alpha),
		A.GetDataConstVoid(), A.GetM(), 
		X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(beta),
		Y.GetDataVoid(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<double> alpha,
	      const Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
	      const Vector<complex<double>, Vect_Full, Allocator1>& X,
	      const complex<double> beta,
	      Vector<complex<double>, Vect_Full, Allocator2>& Y)
  {
    cblas_zhemv(CblasColMajor, CblasUpper,
		A.GetM(), reinterpret_cast<const void*>(alpha),
		A.GetDataConstVoid(), A.GetM(),
		X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(beta),
		Y.GetDataVoid(), 1);
  }


  /*** ColHerm and Uplo ***/


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<float> alpha,
	      const enum CBLAS_UPLO Uplo,
	      const Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
	      const Vector<complex<float>, Vect_Full, Allocator1>& X,
	      const complex<float> beta,
	      Vector<complex<float>, Vect_Full, Allocator2>& Y)
  {
    cblas_chemv(CblasColMajor, Uplo,
		A.GetM(), reinterpret_cast<const void*>(alpha),
		A.GetDataConstVoid(), A.GetM(),
		X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(beta),
		Y.GetDataVoid(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<double> alpha,
	      const enum CBLAS_UPLO Uplo,
	      const Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
	      const Vector<complex<double>, Vect_Full, Allocator1>& X,
	      const complex<double> beta,
	      Vector<complex<double>, Vect_Full, Allocator2>& Y)
  {
    cblas_zhemv(CblasColMajor, Uplo,
		A.GetM(), reinterpret_cast<const void*>(alpha),
		A.GetDataConstVoid(), A.GetM(),
		X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(beta),
		Y.GetDataVoid(), 1);
  }


  /*** RowHerm and Upper ***/


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<float> alpha,
	      const Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
	      const Vector<complex<float>, Vect_Full, Allocator1>& X,
	      const complex<float> beta,
	      Vector<complex<float>, Vect_Full, Allocator2>& Y)
  {
    cblas_chemv(CblasRowMajor, CblasUpper,
		A.GetM(), reinterpret_cast<const void*>(alpha),
		A.GetDataConstVoid(), A.GetM(),
		X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(beta),
		Y.GetDataVoid(), 1);
  }


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<double> alpha,
	      const Matrix<complex<double>, Prop0, RowHerm, Allocator0>& A,
	      const Vector<complex<double>, Vect_Full, Allocator1>& X,
	      const complex<double> beta,
	      Vector<complex<double>, Vect_Full, Allocator2>& Y)
  {
    cblas_zhemv(CblasRowMajor, CblasUpper,
		A.GetM(), reinterpret_cast<const void*>(alpha),
		A.GetDataConstVoid(), A.GetM(),
		X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(beta),
		Y.GetDataVoid(), 1);
  }


  /*** RowHerm and Uplo ***/


  template <class Prop0, class Allocator0,
	    class Allocator1, class Allocator2>
  void MltAdd(const complex<float> alpha,
	      const enum CBLAS_UPLO Uplo,
	      const Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
	      const Vector<complex<float>, Vect_Full, Allocator1>& X,
	      const complex<float> beta,