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