CPPLapack
 All Classes Files Functions Variables Friends Pages
dgematrix-dgematrix.hpp
Go to the documentation of this file.
1 //=============================================================================
2 /*! dgematrix=dgematrix operator */
4 {CPPL_VERBOSE_REPORT;
5  if(array!=mat.array){ // if it is NOT self substitution
6  copy(mat);
7  }
8  return *this;
9 }
10 
11 ///////////////////////////////////////////////////////////////////////////////
12 ///////////////////////////////////////////////////////////////////////////////
13 ///////////////////////////////////////////////////////////////////////////////
14 
15 //=============================================================================
16 /*! dgematrix+=dgematrix operator */
18 {CPPL_VERBOSE_REPORT;
19 #ifdef CPPL_DEBUG
20  if(n!=mat.n || m!=mat.m){
21  ERROR_REPORT;
22  std::cerr << "These two matrises can not make a summation." << std::endl
23  << "Your input was (" << m << "x" << n << ") += (" << mat.m << "x" << mat.n << ")." << std::endl;
24  exit(1);
25  }
26 #endif//CPPL_DEBUG
27 
28  const CPPL_INT mn =m*n;
29  for(CPPL_INT i=0; i<mn; i++){
30  array[i]+=mat.array[i];
31  }
32  return *this;
33 }
34 
35 //=============================================================================
36 /*! dgematrix operator-= */
38 {CPPL_VERBOSE_REPORT;
39 #ifdef CPPL_DEBUG
40  if(n!=mat.n || m!=mat.m){
41  ERROR_REPORT;
42  std::cerr << "These two matrises can not make a sutraction." << std::endl
43  << "Your input was (" << m << "x" << n << ") -= (" << mat.m << "x" << mat.n << ")." << std::endl;
44  exit(1);
45  }
46 #endif//CPPL_DEBUG
47 
48  const CPPL_INT mn =m*n;
49  for(CPPL_INT i=0; i<mn; i++){
50  array[i]-=mat.array[i];
51  }
52  return *this;
53 }
54 
55 //=============================================================================
56 /*! dgematrix operator*= */
58 {CPPL_VERBOSE_REPORT;
59 #ifdef CPPL_DEBUG
60  if(n!=mat.m){
61  ERROR_REPORT;
62  std::cerr << "These two matrises can not make a product." << std::endl
63  << "Your input was (" << m << "x" << n << ") *= (" << mat.m << "x" << mat.n << ")." << std::endl;
64  exit(1);
65  }
66 #endif//CPPL_DEBUG
67 
68  dgematrix newmat( m, mat.n );
69  char transa ='n';
70  char transb ='n';
71  double alpha =1.;
72  double beta =0.;
73 
74  dgemm_( &transa, &transb, &m, &mat.n, &n, &alpha, array, &m, mat.array, &mat.m, &beta, newmat.array, &m );
75 
76  swap(*this,newmat);
77  return *this;
78 }
79 
80 ///////////////////////////////////////////////////////////////////////////////
81 ///////////////////////////////////////////////////////////////////////////////
82 ///////////////////////////////////////////////////////////////////////////////
83 
84 //=============================================================================
85 /*! dgematrix+dgematrix operator */
86 inline _dgematrix operator+(const dgematrix& matA, const dgematrix& matB)
87 {CPPL_VERBOSE_REPORT;
88 #ifdef CPPL_DEBUG
89  if(matA.n!=matB.n || matA.m!=matB.m){
90  ERROR_REPORT;
91  std::cerr << "These two matrises can not make a summation." << std::endl
92  << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.m << "x" << matB.n << ")." << std::endl;
93  exit(1);
94  }
95 #endif//CPPL_DEBUG
96 
97  dgematrix newmat(matA.m,matA.n);
98 
99  const CPPL_INT mn =newmat.m*newmat.n;
100  for(CPPL_INT i=0; i<mn; i++){
101  newmat.array[i] =matA.array[i]+matB.array[i];
102  }
103 
104  return _(newmat);
105 }
106 
107 //=============================================================================
108 /*! dgematrix-dgematrix operator */
109 inline _dgematrix operator-(const dgematrix& matA, const dgematrix& matB)
110 {CPPL_VERBOSE_REPORT;
111 #ifdef CPPL_DEBUG
112  if(matA.n!=matB.n || matA.m!=matB.m){
113  ERROR_REPORT;
114  std::cerr << "These two matrises can not make a subtraction." << std::endl
115  << "Your input was (" << matA.m << "x" << matA.n << ") - (" << matB.m << "x" << matB.n << ")." << std::endl;
116  exit(1);
117  }
118 #endif//CPPL_DEBUG
119 
120  dgematrix newmat(matA.m,matA.n);
121 
122  const CPPL_INT mn =newmat.m*newmat.n;
123  for(CPPL_INT i=0; i<mn; i++){
124  newmat.array[i] =matA.array[i]-matB.array[i];
125  }
126 
127  return _(newmat);
128 }
129 
130 //=============================================================================
131 /*! dgematrix*dgematrix operator */
132 inline _dgematrix operator*(const dgematrix& matA, const dgematrix& matB)
133 {CPPL_VERBOSE_REPORT;
134 #ifdef CPPL_DEBUG
135  if(matA.n!=matB.m){
136  ERROR_REPORT;
137  std::cerr << "These two matrises can not make a product." << std::endl
138  << "Your input was (" << matA.m << "x" << matA.n << ") * (" << matB.m << "x" << matB.n << ")." << std::endl;
139  exit(1);
140  }
141 #endif//CPPL_DEBUG
142 
143  dgematrix newmat( matA.m, matB.n );
144  char transa ='n';
145  char transb ='n';
146  double alpha =1.;
147  double beta =0.;
148 
149  dgemm_( &transa, &transb, &matA.m, &matB.n, &matA.n, &alpha, matA.array, &matA.m, matB.array, &matB.m, &beta, newmat.array, &matA.m );
150 
151  return _(newmat);
152 }
153 
154 //=============================================================================
155 /*! dgematrix%dgematrix operator */
156 inline _drovector operator%(const dgematrix& matA, const dgematrix& matB)
157 {CPPL_VERBOSE_REPORT;
158 #ifdef CPPL_DEBUG
159  if(matA.m!=matB.m || matA.n!=matB.n){
160  ERROR_REPORT;
161  std::cerr << "These two matrises can not make a product." << std::endl
162  << "Your input was (" << matA.m << "x" << matA.n << ") % (" << matB.m << "x" << matB.n << ")." << std::endl;
163  exit(1);
164  }
165 #endif//CPPL_DEBUG
166 
167  drovector newvec( matA.n );
168 
169  newvec.zero();
170  for(CPPL_INT j=0; j<matA.n; j++){
171  for(CPPL_INT i=0; i<matA.m; i++){
172  newvec(j) +=matA(i,j)*matB(i,j);
173  }
174  }
175 
176  return _(newvec);
177 }
178 
179 ///////////////////////////////////////////////////////////////////////////////
180 ///////////////////////////////////////////////////////////////////////////////
181 ///////////////////////////////////////////////////////////////////////////////
182 
183 //=============================================================================
184 /*! return Hadamerd product */
185 inline _dgematrix hadamerd(const dgematrix& matA, const dgematrix& matB)
186 {CPPL_VERBOSE_REPORT;
187 #ifdef CPPL_DEBUG
188  if( matA.m!=matB.m || matA.n!=matB.n ){
189  ERROR_REPORT;
190  std::cerr << "These two matrices can not make Hadamerd product." << std::endl
191  << "Your input was (" << matA.m << "x" << matA.n << ") and (" << matB.m << "x" << matB.n << ")." << std::endl;
192  exit(1);
193  }
194 #endif//CPPL_DEBUG
195 
196  dgematrix newmat(matA.m,matA.n);
197  for(CPPL_INT i=0; i<newmat.m; i++){
198  for(CPPL_INT j=0; j<newmat.n; j++){
199  newmat(i,j) =matA(i,j)*matB(i,j);
200  }
201  }
202  return _(newmat);
203 }
_dgematrix operator+(const dgematrix &matA, const dgematrix &matB)
CPPL_INT m
matrix row size
Definition: dgematrix.hpp:9
double * array
1D array to store matrix data
Definition: dgematrix.hpp:11
_dgematrix operator-(const dgematrix &matA, const dgematrix &matB)
_dgematrix i(const _dgbmatrix &mat)
friend void swap(dgematrix &, dgematrix &)
CPPL_INT n
matrix column size
Definition: dgematrix.hpp:10
Real Double-precision General Dence Matrix Class.
Definition: dgematrix.hpp:3
dgematrix & operator=(const dgematrix &)
Real Double-precision Row Vector Class.
Definition: drovector.hpp:3
dgematrix & operator*=(const dgematrix &)
_dgematrix operator*(const dgematrix &matA, const dgematrix &matB)
drovector & zero()
(DO NOT USE) Smart-temporary Real Double-precision Row Vector Class
Definition: _drovector.hpp:3
(DO NOT USE) Smart-temporary Real Double-precision General Dence Matrix Class
Definition: _dgematrix.hpp:3
void copy(const dgematrix &)
_drovector operator%(const dgematrix &matA, const dgematrix &matB)
_dgematrix hadamerd(const dgematrix &matA, const dgematrix &matB)
dgematrix & operator-=(const dgematrix &)
friend _dgematrix i(const dgematrix &)
dgematrix & operator+=(const dgematrix &)
_dcovector _(dcovector &vec)