My Project
Loading...
Searching...
No Matches
Functions
lq Namespace Reference

Functions

template<unsigned int Precision>
void rmatrixlq (ap::template_2d_array< amp::ampf< Precision > > &a, int m, int n, ap::template_1d_array< amp::ampf< Precision > > &tau)
 
template<unsigned int Precision>
void rmatrixlqunpackq (const ap::template_2d_array< amp::ampf< Precision > > &a, int m, int n, const ap::template_1d_array< amp::ampf< Precision > > &tau, int qrows, ap::template_2d_array< amp::ampf< Precision > > &q)
 
template<unsigned int Precision>
void rmatrixlqunpackl (const ap::template_2d_array< amp::ampf< Precision > > &a, int m, int n, ap::template_2d_array< amp::ampf< Precision > > &l)
 
template<unsigned int Precision>
void lqdecomposition (ap::template_2d_array< amp::ampf< Precision > > &a, int m, int n, ap::template_1d_array< amp::ampf< Precision > > &tau)
 
template<unsigned int Precision>
void unpackqfromlq (const ap::template_2d_array< amp::ampf< Precision > > &a, int m, int n, const ap::template_1d_array< amp::ampf< Precision > > &tau, int qrows, ap::template_2d_array< amp::ampf< Precision > > &q)
 
template<unsigned int Precision>
void lqdecompositionunpacked (ap::template_2d_array< amp::ampf< Precision > > a, int m, int n, ap::template_2d_array< amp::ampf< Precision > > &l, ap::template_2d_array< amp::ampf< Precision > > &q)
 

Function Documentation

◆ lqdecomposition()

template<unsigned int Precision>
void lq::lqdecomposition ( ap::template_2d_array< amp::ampf< Precision > > &  a,
int  m,
int  n,
ap::template_1d_array< amp::ampf< Precision > > &  tau 
)

Definition at line 288 of file lq.h.

292 {
293 ap::template_1d_array< amp::ampf<Precision> > work;
294 ap::template_1d_array< amp::ampf<Precision> > t;
295 int i;
296 int k;
297 int nmip1;
298 int minmn;
299 int maxmn;
300 amp::ampf<Precision> tmp;
301
302
303 minmn = ap::minint(m, n);
304 maxmn = ap::maxint(m, n);
305 work.setbounds(1, m);
306 t.setbounds(1, n);
307 tau.setbounds(1, minmn);
308
309 //
310 // Test the input arguments
311 //
312 k = ap::minint(m, n);
313 for(i=1; i<=k; i++)
314 {
315
316 //
317 // Generate elementary reflector H(i) to annihilate A(i,i+1:n)
318 //
319 nmip1 = n-i+1;
320 ap::vmove(t.getvector(1, nmip1), a.getrow(i, i, n));
321 reflections::generatereflection<Precision>(t, nmip1, tmp);
322 tau(i) = tmp;
323 ap::vmove(a.getrow(i, i, n), t.getvector(1, nmip1));
324 t(1) = 1;
325 if( i<n )
326 {
327
328 //
329 // Apply H(i) to A(i+1:m,i:n) from the right
330 //
331 reflections::applyreflectionfromtheright<Precision>(a, tau(i), t, i+1, m, i, n, work);
332 }
333 }
334 }
m
int m
Definition cfEzgcd.cc:128
i
int i
Definition cfEzgcd.cc:132
k
int k
Definition cfEzgcd.cc:99
tau
void tau(int **points, int sizePoints, int k)
Definition cfNewtonPolygon.cc:461
ap::template_1d_array
Definition ap.h:657
ap::template_1d_array::getvector
raw_vector< T > getvector(int iStart, int iEnd)
Definition ap.h:776
ap::template_1d_array::setbounds
void setbounds(int iLow, int iHigh)
Definition ap.h:735
ap::template_2d_array::getrow
raw_vector< T > getrow(int iRow, int iColumnStart, int iColumnEnd)
Definition ap.h:939
ap::maxint
int maxint(int m1, int m2)
Definition ap.cpp:162
ap::vmove
void vmove(raw_vector< T > vdst, const_raw_vector< T > vsrc)
Definition ap.h:237
ap::minint
int minint(int m1, int m2)
Definition ap.cpp:167

◆ lqdecompositionunpacked()

template<unsigned int Precision>
void lq::lqdecompositionunpacked ( ap::template_2d_array< amp::ampf< Precision > >  a,
int  m,
int  n,
ap::template_2d_array< amp::ampf< Precision > > &  l,
ap::template_2d_array< amp::ampf< Precision > > &  q 
)

Definition at line 408 of file lq.h.

413 {
414 int i;
415 int j;
416 ap::template_1d_array< amp::ampf<Precision> > tau;
417
418
419 if( n<=0 )
420 {
421 return;
422 }
423 q.setbounds(1, n, 1, n);
424 l.setbounds(1, m, 1, n);
425
426 //
427 // LQDecomposition
428 //
429 lqdecomposition<Precision>(a, m, n, tau);
430
431 //
432 // L
433 //
434 for(i=1; i<=m; i++)
435 {
436 for(j=1; j<=n; j++)
437 {
438 if( j>i )
439 {
440 l(i,j) = 0;
441 }
442 else
443 {
444 l(i,j) = a(i,j);
445 }
446 }
447 }
448
449 //
450 // Q
451 //
452 unpackqfromlq<Precision>(a, m, n, tau, n, q);
453 }
l
int l
Definition cfEzgcd.cc:100
ap::template_2d_array::setbounds
void setbounds(int iLow1, int iHigh1, int iLow2, int iHigh2)
Definition ap.h:890
j
int j
Definition facHensel.cc:110

◆ rmatrixlq()

template<unsigned int Precision>
void lq::rmatrixlq ( ap::template_2d_array< amp::ampf< Precision > > &  a,
int  m,
int  n,
ap::template_1d_array< amp::ampf< Precision > > &  tau 
)

Definition at line 113 of file lq.h.

117 {
118 ap::template_1d_array< amp::ampf<Precision> > work;
119 ap::template_1d_array< amp::ampf<Precision> > t;
120 int i;
121 int k;
122 int minmn;
123 int maxmn;
124 amp::ampf<Precision> tmp;
125
126
127 minmn = ap::minint(m, n);
128 maxmn = ap::maxint(m, n);
129 work.setbounds(0, m);
130 t.setbounds(0, n);
131 tau.setbounds(0, minmn-1);
132 k = ap::minint(m, n);
133 for(i=0; i<=k-1; i++)
134 {
135
136 //
137 // Generate elementary reflector H(i) to annihilate A(i,i+1:n-1)
138 //
139 ap::vmove(t.getvector(1, n-i), a.getrow(i, i, n-1));
140 reflections::generatereflection<Precision>(t, n-i, tmp);
141 tau(i) = tmp;
142 ap::vmove(a.getrow(i, i, n-1), t.getvector(1, n-i));
143 t(1) = 1;
144 if( i<n )
145 {
146
147 //
148 // Apply H(i) to A(i+1:m,i:n) from the right
149 //
150 reflections::applyreflectionfromtheright<Precision>(a, tau(i), t, i+1, m-1, i, n-1, work);
151 }
152 }
153 }

◆ rmatrixlqunpackl()

template<unsigned int Precision>
void lq::rmatrixlqunpackl ( const ap::template_2d_array< amp::ampf< Precision > > &  a,
int  m,
int  n,
ap::template_2d_array< amp::ampf< Precision > > &  l 
)

Definition at line 253 of file lq.h.

257 {
258 int i;
259 int k;
260
261
262 if( m<=0 || n<=0 )
263 {
264 return;
265 }
266 l.setbounds(0, m-1, 0, n-1);
267 for(i=0; i<=n-1; i++)
268 {
269 l(0,i) = 0;
270 }
271 for(i=1; i<=m-1; i++)
272 {
273 ap::vmove(l.getrow(i, 0, n-1), l.getrow(0, 0, n-1));
274 }
275 for(i=0; i<=m-1; i++)
276 {
277 k = ap::minint(i, n-1);
278 ap::vmove(l.getrow(i, 0, k), a.getrow(i, 0, k));
279 }
280 }

◆ rmatrixlqunpackq()

template<unsigned int Precision>
void lq::rmatrixlqunpackq ( const ap::template_2d_array< amp::ampf< Precision > > &  a,
int  m,
int  n,
const ap::template_1d_array< amp::ampf< Precision > > &  tau,
int  qrows,
ap::template_2d_array< amp::ampf< Precision > > &  q 
)

Definition at line 177 of file lq.h.

183 {
184 int i;
185 int j;
186 int k;
187 int minmn;
188 ap::template_1d_array< amp::ampf<Precision> > v;
189 ap::template_1d_array< amp::ampf<Precision> > work;
190
191
192 ap::ap_error::make_assertion(qrows<=n);
193 if( m<=0 || n<=0 || qrows<=0 )
194 {
195 return;
196 }
197
198 //
199 // init
200 //
201 minmn = ap::minint(m, n);
202 k = ap::minint(minmn, qrows);
203 q.setbounds(0, qrows-1, 0, n-1);
204 v.setbounds(0, n);
205 work.setbounds(0, qrows);
206 for(i=0; i<=qrows-1; i++)
207 {
208 for(j=0; j<=n-1; j++)
209 {
210 if( i==j )
211 {
212 q(i,j) = 1;
213 }
214 else
215 {
216 q(i,j) = 0;
217 }
218 }
219 }
220
221 //
222 // unpack Q
223 //
224 for(i=k-1; i>=0; i--)
225 {
226
227 //
228 // Apply H(i)
229 //
230 ap::vmove(v.getvector(1, n-i), a.getrow(i, i, n-1));
231 v(1) = 1;
232 reflections::applyreflectionfromtheright<Precision>(q, tau(i), v, 0, qrows-1, i, n-1, work);
233 }
234 }
ap::ap_error::make_assertion
static void make_assertion(bool bClause)
Definition ap.h:49
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39

◆ unpackqfromlq()

template<unsigned int Precision>
void lq::unpackqfromlq ( const ap::template_2d_array< amp::ampf< Precision > > &  a,
int  m,
int  n,
const ap::template_1d_array< amp::ampf< Precision > > &  tau,
int  qrows,
ap::template_2d_array< amp::ampf< Precision > > &  q 
)

Definition at line 342 of file lq.h.

348 {
349 int i;
350 int j;
351 int k;
352 int minmn;
353 ap::template_1d_array< amp::ampf<Precision> > v;
354 ap::template_1d_array< amp::ampf<Precision> > work;
355 int vm;
356
357
358 ap::ap_error::make_assertion(qrows<=n);
359 if( m==0 || n==0 || qrows==0 )
360 {
361 return;
362 }
363
364 //
365 // init
366 //
367 minmn = ap::minint(m, n);
368 k = ap::minint(minmn, qrows);
369 q.setbounds(1, qrows, 1, n);
370 v.setbounds(1, n);
371 work.setbounds(1, qrows);
372 for(i=1; i<=qrows; i++)
373 {
374 for(j=1; j<=n; j++)
375 {
376 if( i==j )
377 {
378 q(i,j) = 1;
379 }
380 else
381 {
382 q(i,j) = 0;
383 }
384 }
385 }
386
387 //
388 // unpack Q
389 //
390 for(i=k; i>=1; i--)
391 {
392
393 //
394 // Apply H(i)
395 //
396 vm = n-i+1;
397 ap::vmove(v.getvector(1, vm), a.getrow(i, i, n));
398 v(1) = 1;
399 reflections::applyreflectionfromtheright<Precision>(q, tau(i), v, 1, qrows, i, n, work);
400 }
401 }
Generated on Sat Feb 1 2025 17:25:29 for My Project by   doxygen 1.9.8 for Singular