1/* 2 * Copyright (C) 2014,2015 the FFLAS-FFPACK group 3 * 4 * Written by Clement Pernet <Clement.Pernet@imag.fr> 5 * Brice Boyer (briceboyer) <boyer.brice@gmail.com> 6 * 7 * 8 * ========LICENCE======== 9 * This file is part of the library FFLAS-FFPACK. 10 * 11 * FFLAS-FFPACK is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public 13 * License as published by the Free Software Foundation; either 14 * version 2.1 of the License, or (at your option) any later version. 15 * 16 * This library is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * Lesser General Public License for more details. 20 * 21 * You should have received a copy of the GNU Lesser General Public 22 * License along with this library; if not, write to the Free Software 23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 24 * ========LICENCE======== 25 *. 26 */ 27 28 29namespace FFLAS { 30 //--------------------------------------------------------------------- 31 // Level 1 routines 32 //--------------------------------------------------------------------- 33 34 /** freduce 35 * \f$x \gets x mod F\f$. 36 * @param F field 37 * @param n size of the vectors 38 * \param X vector in \p F 39 * \param incX stride of \p X 40 * @bug use cblas_(d)scal when possible 41 */ 42 template INST_OR_DECL 43 void 44 freduce (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 45 FFLAS_ELT* X, const size_t incX); 46 47 /** freduce 48 * \f$x \gets y mod F\f$. 49 * @param F field 50 * @param n size of the vectors 51 * \param Y vector of \p Element 52 * \param incY stride of \p Y 53 * \param X vector in \p F 54 * \param incX stride of \p X 55 * @bug use cblas_(d)scal when possible 56 */ 57 template INST_OR_DECL 58 void 59 freduce (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 60 const FFLAS_ELT* Y, const size_t incY, 61 FFLAS_ELT* X, const size_t incX); 62 63 /** finit 64 * \f$x \gets y mod F\f$. 65 * @param F field 66 * @param n size of the vectors 67 * \param Y vector of \p OtherElement 68 * \param incY stride of \p Y 69 * \param X vector in \p F 70 * \param incX stride of \p X 71 * @bug use cblas_(d)scal when possible 72 */ 73 template INST_OR_DECL 74 void 75 finit (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 76 const FFLAS_ELT* Y, const size_t incY, 77 FFLAS_ELT* X, const size_t incX); 78 79 /** fconvert 80 * \f$x \gets y mod F\f$. 81 * @param F field 82 * @param n size of the vectors 83 * \param Y vector of \p F 84 * \param incY stride of \p Y 85 * \param X vector in \p OtherElement 86 * \param incX stride of \p X 87 * @bug use cblas_(d)scal when possible 88 */ 89 template INST_OR_DECL 90 void 91 fconvert (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 92 FFLAS_ELT* X, const size_t incX, 93 const FFLAS_ELT* Y, const size_t incY); 94 // { 95 // OtherElement_ptr Xi = X ; 96 // const FFLAS_ELT* Yi = Y ; 97 // for (; Xi < X+n*incX; Xi+=incX, Yi += incY ) 98 // F.convert( *Xi , *Yi); 99 // } 100 101 /** fnegin 102 * \f$x \gets - x\f$. 103 * @param F field 104 * @param n size of the vectors 105 * \param X vector in \p F 106 * \param incX stride of \p X 107 * @bug use cblas_(d)scal when possible 108 */ 109 template INST_OR_DECL 110 void 111 fnegin (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 112 FFLAS_ELT* X, const size_t incX); 113 // { 114 // FFLAS_ELT* Xi = X ; 115 // for (; Xi < X+n*incX; Xi+=incX ) 116 // F.negin( *Xi ); 117 // } 118 119 /** fneg 120 * \f$x \gets - y\f$. 121 * @param F field 122 * @param n size of the vectors 123 * \param X vector in \p F 124 * \param incX stride of \p X 125 * \param Y vector in \p F 126 * \param incY stride of \p Y 127 * @bug use cblas_(d)scal when possible 128 */ 129 template INST_OR_DECL 130 void 131 fneg (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 132 const FFLAS_ELT* Y, const size_t incY, 133 FFLAS_ELT* X, const size_t incX); 134 // { 135 // FFLAS_ELT* Xi = X ; 136 // const FFLAS_ELT* Yi = Y ; 137 // for (; Xi < X+n*incX; Xi+=incX,Yi+=incY ) 138 // F.neg( *Xi, *Yi ); 139 // } 140 141 /** \brief fzero : \f$A \gets 0 \f$. 142 * @param F field 143 * @param n number of elements to zero 144 * \param X vector in \p F 145 * \param incX stride of \p X 146 */ 147 template INST_OR_DECL 148 void 149 fzero (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 150 FFLAS_ELT* X, const size_t incX); 151 // { 152 // if (incX == 1) { // contigous data 153 // // memset(X,(int)F.zero,n); // might be bogus ? 154 // for (size_t i = 0 ; i < n ; ++i) 155 // F.assign(*(X+i), F.zero); 156 157 // } 158 // else { // not contiguous (strided) 159 // for (size_t i = 0 ; i < n ; ++i) 160 // F.assign(*(X+i*incX), F.zero); 161 // } 162 // } 163 164 /** \brief fiszero : test \f$X = 0 \f$. 165 * @param F field 166 * @param n vector dimension 167 * \param X vector in \p F 168 * \param incX increment of \p X 169 */ 170 template INST_OR_DECL 171 bool 172 fiszero (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 173 const FFLAS_ELT* X, const size_t incX); 174 // { 175 // bool res=true; 176 // for (size_t i = 0 ; i < n ; ++i) 177 // res &= F.isZero (X [i*incX]); 178 // return res; 179 // } 180 181 /** \brief fequal : test \f$X = Y \f$. 182 * @param F field 183 * @param n vector dimension 184 * \param X vector in \p F 185 * \param incX increment of \p X 186 * \param Y vector in \p F 187 * \param incY increment of \p Y 188 */ 189 template INST_OR_DECL 190 bool 191 fequal (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, 192 const FFLAS_ELT* X, const size_t incX, 193 const FFLAS_ELT* Y, const size_t incY); 194 // { 195 // bool res=true; 196 // for (size_t i = 0 ; i < n ; ++i) 197 // res &= F.areEqual (X [i*incX], Y [i*incY]); 198 // return res; 199 // } 200 201 /** \brief fassign : \f$x \gets y \f$. 202 * X is preallocated 203 * @todo variant for triagular matrix 204 * @param F field 205 * @param N size of the vectors 206 * \param [out] X vector in \p F 207 * \param incX stride of \p X 208 * \param [in] Y vector in \p F 209 * \param incY stride of \p Y 210 */ 211 template INST_OR_DECL 212 void 213 fassign (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 214 const FFLAS_ELT* Y, const size_t incY , 215 FFLAS_ELT* X, const size_t incX); 216 217 218 /** fscalin 219 * \f$x \gets \alpha \cdot x\f$. 220 * @param F field 221 * @param n size of the vectors 222 * @param alpha scalar 223 * \param X vector in \p F 224 * \param incX stride of \p X 225 * @bug use cblas_(d)scal when possible 226 * @internal 227 * @todo check if comparison with +/-1,0 is necessary. 228 */ 229 template INST_OR_DECL 230 void 231 fscalin (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n, const FFLAS_ELT alpha, 232 FFLAS_ELT* X, const size_t incX); 233 234 235 /** fscal 236 * \f$y \gets \alpha \cdot x\f$. 237 * @param F field 238 * @param n size of the vectors 239 * @param alpha scalar 240 * \param[in] X vector in \p F 241 * \param incX stride of \p X 242 * \param[out] Y vector in \p F 243 * \param incY stride of \p Y 244 * @bug use cblas_(d)scal when possible 245 * @internal 246 * @todo check if comparison with +/-1,0 is necessary. 247 */ 248 template INST_OR_DECL 249 void 250 fscal (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t n 251 , const FFLAS_ELT alpha 252 , const FFLAS_ELT* X, const size_t incX 253 , FFLAS_ELT* Y, const size_t incY); 254 255 256 257 /** \brief faxpy : \f$y \gets \alpha \cdot x + y\f$. 258 * @param F field 259 * @param N size of the vectors 260 * @param alpha scalar 261 * \param[in] X vector in \p F 262 * \param incX stride of \p X 263 * \param[in,out] Y vector in \p F 264 * \param incY stride of \p Y 265 */ 266 template INST_OR_DECL 267 void 268 faxpy (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 269 const FFLAS_ELT alpha, 270 const FFLAS_ELT* X, const size_t incX, 271 FFLAS_ELT* Y, const size_t incY ); 272 273 /** \brief faxpby : \f$y \gets \alpha \cdot x + \beta \cdot y\f$. 274 * @param F field 275 * @param N size of the vectors 276 * @param alpha scalar 277 * \param[in] X vector in \p F 278 * \param incX stride of \p X 279 * \param beta scalar 280 * \param[in,out] Y vector in \p F 281 * \param incY stride of \p Y 282 * \note this is a catlas function 283 */ 284 // template INST_OR_DECL 285 // void 286 // faxpby (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 287 // const FFLAS_ELT alpha, 288 // const FFLAS_ELT* X, const size_t incX, 289 // const FFLAS_ELT beta, 290 // FFLAS_ELT* Y, const size_t incY ); 291 292 293 /** \brief fdot: dot product \f$x^T y\f$. 294 * @param F field 295 * @param N size of the vectors 296 * \param X vector in \p F 297 * \param incX stride of \p X 298 * \param Y vector in \p F 299 * \param incY stride of \p Y 300 */ 301 template INST_OR_DECL 302 FFLAS_ELT 303 fdot (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 304 const FFLAS_ELT* X, const size_t incX, 305 const FFLAS_ELT* Y, const size_t incY ); 306 307 /** \brief fswap: \f$ X \leftrightarrow Y\f$. 308 * @bug use cblas_dswap when double 309 * @param F field 310 * @param N size of the vectors 311 * \param X vector in \p F 312 * \param incX stride of \p X 313 * \param Y vector in \p F 314 * \param incY stride of \p Y 315 */ 316 template INST_OR_DECL 317 void 318 fswap (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, FFLAS_ELT* X, const size_t incX, 319 FFLAS_ELT* Y, const size_t incY ); 320 // { 321 322 // FFLAS_ELT tmp; F.init(tmp); 323 // FFLAS_ELT* Xi = X; 324 // FFLAS_ELT* Yi=Y; 325 // for (; Xi < X+N*incX; Xi+=incX, Yi+=incY ){ 326 // F.assign( tmp, *Xi ); 327 // F.assign( *Xi, *Yi ); 328 // F.assign( *Yi, tmp ); 329 // } 330 // } 331 332 template INST_OR_DECL 333 void 334 fadd (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 335 const FFLAS_ELT* A, const size_t inca, 336 const FFLAS_ELT* B, const size_t incb, 337 FFLAS_ELT* C, const size_t incc); 338 339 template INST_OR_DECL 340 void 341 fsub (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 342 const FFLAS_ELT* A, const size_t inca, 343 const FFLAS_ELT* B, const size_t incb, 344 FFLAS_ELT* C, const size_t incc); 345 346 template INST_OR_DECL 347 void 348 faddin (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 349 const FFLAS_ELT* B, const size_t incb, 350 FFLAS_ELT* C, const size_t incc); 351 352 // template INST_OR_DECL 353 // void 354 // fsubin (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 355 // FFLAS_ELT* C, const size_t incc); 356 357 358 template INST_OR_DECL 359 void 360 fadd (const FFLAS_FIELD<FFLAS_ELT>& F, const size_t N, 361 const FFLAS_ELT* A, const size_t inca, 362 const FFLAS_ELT alpha, 363 const FFLAS_ELT* B, const size_t incb, 364 FFLAS_ELT* C, const size_t incc); 365 366} // FFLAS 367 368/* -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ 369// vim:sts=4:sw=4:ts=4:et:sr:cino=>s,f0,{0,g0,(0,\:0,t0,+0,=s 370