1 PACKAGE UTL_NLA as
2
3 --
4 -- Types
5 --
6
7 SUBTYPE scalar_double IS BINARY_DOUBLE NOT NULL;
8 SUBTYPE scalar_float IS BINARY_FLOAT NOT NULL;
9
10 SUBTYPE flag IS CHAR(1) NOT NULL;
11
12 -- -------------------------------------------------------------
13 -- flag | legal values
14 -- -------------------------------------------------------------
15 -- trans | 'N' or 'n' => No traspose
16 -- | 'T' or 't' => Transpose
17 -- |
18 -- uplo | 'U' or 'u' => Upper-triangular
19 -- | 'L' or 'l' => Lower-triangular
20 -- |
21 -- diag | 'N' or 'n' => Non-unit triangular
22 -- | 'U' or 'u' => Unit triangular
23 -- |
24 -- side | 'L' or 'l' => Left
25 -- | 'R' or 'r' => Right
26 -- |
27 -- pack | 'R' or 'r' => Row-major array
28 -- | 'C' or 'c' => Column-major array
29 -- |
30 -- jobz | 'N' => only eigenvalues computed
31 -- | 'V' => both eigenvalues and eigenvectors computed
32 -- |
33 -- -------------------------------------------------------------
34
35 -- ------------- --
36 -- Unit Testing
37 -- ------------- --
38
39 PROCEDURE unit_test_blas;
40 PROCEDURE unit_test_lapack;
41
42 -- --------------------------------------- --
43 -- BLAS Level 1 (Vector-Vector Operations)
44 -- --------------------------------------- --
45
46 -- Purpose
47 -- =======
48 --
49 -- BLAS_SWAPS swaps the contents of two vectors each of size n.
50 --
51 -- Arguments
52 -- =========
53 --
54 -- N - INTEGER.
55 -- On entry, N specifies the number of elements of the vectors X and Y.
56 -- N must be at least zero.
57 -- Unchanged on exit.
58 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
59 -- ( 1 + ( n - 1 )*abs( INCX ) )
60 -- INCX - INTEGER.
61 -- On entry, INCX specifies the increment for the elements of
62 -- X. INCX must not be zero.
63 -- Unchanged on exit.
64 -- Y - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
65 -- ( 1 + ( n - 1 )*abs( INCY ) )
66 -- INCY - INTEGER.
67 -- On entry, INCY specifies the increment for the elements of
68 -- Y. INCY must not be zero.
69 -- Unchanged on exit.
70
71 PROCEDURE blas_swap(n IN POSITIVEN,
72 x IN OUT utl_nla_array_dbl,
73 incx IN POSITIVEN,
74 y IN OUT utl_nla_array_dbl,
75 incy IN POSITIVEN);
76
77 PROCEDURE blas_swap(n IN POSITIVEN,
78 x IN OUT UTL_NLA_ARRAY_FLT,
79 incx IN POSITIVEN,
80 y IN OUT UTL_NLA_ARRAY_FLT,
81 incy IN POSITIVEN);
82
83 -- Purpose
84 -- =======
85 --
86 -- BLAS_SCAL scales a vector by a constant.
87 --
88 -- Arguments
89 -- =========
90 --
91 -- N - INTEGER.
92 -- On entry, N specifies the number of elements of the vectors X and Y.
93 -- N must be at least zero.
94 -- Unchanged on exit.
95 -- ALPHA - SCALAR_FLOAT/DOUBLE .
96 -- On entry, ALPHA specifies the scalar alpha.
97 -- Unchanged on exit.
98 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
99 -- ( 1 + ( n - 1 )*abs( INCX ) )
100 -- INCX - INTEGER.
101 -- On entry, INCX specifies the increment for the elements of
102 -- X. INCX must not be zero.
103 -- Unchanged on exit.
104
105 PROCEDURE blas_scal(n IN POSITIVEN,
106 alpha IN scalar_double,
107 x IN OUT utl_nla_array_dbl,
108 incx IN POSITIVEN);
109
110 PROCEDURE blas_scal(n IN POSITIVEN,
111 alpha IN scalar_float,
112 x IN OUT UTL_NLA_ARRAY_FLT,
113 incx IN POSITIVEN);
114
115 -- Purpose
116 -- =======
117 --
118 -- BLAS_COPY copies the contents of vector X to vector Y.
119 --
120 -- Arguments
121 -- =========
122 --
123 -- N - INTEGER.
124 -- On entry, N specifies the number of elements of the vectors X and Y.
125 -- N must be at least zero.
126 -- Unchanged on exit.
127 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
128 -- ( 1 + ( n - 1 )*abs( INCX ) )
129 -- INCX - INTEGER.
130 -- On entry, INCX specifies the increment for the elements of
131 -- X. INCX must not be zero.
132 -- Unchanged on exit.
133 -- Y - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
134 -- ( 1 + ( n - 1 )*abs( INCY ) )
135 -- INCY - INTEGER.
136 -- On entry, INCY specifies the increment for the elements of
137 -- Y. INCY must not be zero.
138 -- Unchanged on exit.
139
140 PROCEDURE blas_copy(n IN POSITIVEN,
141 x IN utl_nla_array_dbl,
142 incx IN POSITIVEN,
143 y IN OUT utl_nla_array_dbl,
144 incy IN POSITIVEN);
145
146 PROCEDURE blas_copy(n IN POSITIVEN,
147 x IN UTL_NLA_ARRAY_FLT,
148 incx IN POSITIVEN,
149 y IN OUT UTL_NLA_ARRAY_FLT,
150 incy IN POSITIVEN);
151
152 -- Purpose
153 -- =======
154 --
155 -- BLAS_AXPY copies alpha*X + Y into vector Y.
156 --
157 -- Arguments
158 -- =========
159 --
160 -- N - INTEGER.
161 -- On entry, N specifies the number of elements of the vectors X and Y.
162 -- N must be at least zero.
163 -- Unchanged on exit.
164 -- ALPHA - SCALAR_FLOAT/DOUBLE .
165 -- On entry, ALPHA specifies the scalar alpha.
166 -- Unchanged on exit.
167 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
168 -- ( 1 + ( n - 1 )*abs( INCX ) )
169 -- Unchanged on exit.
170 -- INCX - INTEGER.
171 -- On entry, INCX specifies the increment for the elements of
172 -- X. INCX must not be zero.
173 -- Unchanged on exit.
174 -- Y - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
175 -- ( 1 + ( n - 1 )*abs( INCY ) )
176 -- INCY - INTEGER.
177 -- On entry, INCY specifies the increment for the elements of
178 -- Y. INCY must not be zero.
179 -- Unchanged on exit.
180
181 PROCEDURE blas_axpy(n IN POSITIVEN,
182 alpha IN scalar_double,
183 x IN utl_nla_array_dbl,
184 incx IN POSITIVEN,
185 y IN OUT utl_nla_array_dbl,
186 incy IN POSITIVEN);
187
188 PROCEDURE blas_axpy(n IN POSITIVEN,
189 alpha IN scalar_float,
190 x IN UTL_NLA_ARRAY_FLT,
191 incx IN POSITIVEN,
192 y IN OUT UTL_NLA_ARRAY_FLT,
193 incy IN POSITIVEN);
194
195 -- Purpose
196 -- =======
197 --
198 -- BLAS_DOT returns the dot (scalar) product of two vectors X and Y.
199 --
200 -- Arguments
201 -- =========
202 --
203 -- N - INTEGER.
204 -- On entry, N specifies the number of elements of the vectors X and Y.
205 -- N must be at least zero.
206 -- Unchanged on exit.
207 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
208 -- ( 1 + ( n - 1 )*abs( INCX ) )
209 -- Unchanged on exit.
210 -- INCX - INTEGER.
211 -- On entry, INCX specifies the increment for the elements of
212 -- X. INCX must not be zero.
213 -- Unchanged on exit.
214 -- Y - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
215 -- ( 1 + ( n - 1 )*abs( INCY ) )
216 -- Unchanged on exit.
217 -- INCY - INTEGER.
218 -- On entry, INCY specifies the increment for the elements of
219 -- Y. INCY must not be zero.
220 -- Unchanged on exit.
221
222 FUNCTION blas_dot(n IN POSITIVEN,
223 x IN utl_nla_array_dbl,
224 incx IN POSITIVEN,
225 y IN utl_nla_array_dbl,
226 incy IN POSITIVEN) RETURN BINARY_DOUBLE;
227
228 FUNCTION blas_dot(n IN POSITIVEN,
229 x IN UTL_NLA_ARRAY_FLT,
230 incx IN POSITIVEN,
231 y IN UTL_NLA_ARRAY_FLT,
232 incy IN POSITIVEN) RETURN BINARY_FLOAT;
233
234 -- Purpose
235 -- =======
236 --
237 -- BLAS_NRM2 computes the vector 2-norm (Euclidean norm)
238 --
239 -- Arguments
240 -- =========
241 --
242 -- N - INTEGER.
243 -- On entry, N specifies the number of elements of the vectors X and Y.
244 -- N must be at least zero.
245 -- Unchanged on exit.
246 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
247 -- ( 1 + ( n - 1 )*abs( INCX ) )
248 -- Unchanged on exit.
249 -- INCX - INTEGER.
250 -- On entry, INCX specifies the increment for the elements of
251 -- X. INCX must not be zero.
252 -- Unchanged on exit.
253
254 FUNCTION blas_nrm2(n IN POSITIVEN,
255 x IN utl_nla_array_dbl,
256 incx IN POSITIVEN) RETURN BINARY_DOUBLE;
257
258 FUNCTION blas_nrm2(n IN POSITIVEN,
259 x IN UTL_NLA_ARRAY_FLT,
260 incx IN POSITIVEN) RETURN BINARY_FLOAT;
261
262 -- Purpose
263 -- =======
264 --
265 -- BLAS_ASUM computes the sum of the absolute values of the vector components
266 --
267 -- Arguments
268 -- =========
269 --
270 -- N - INTEGER.
271 -- On entry, N specifies the number of elements of the vectors X and Y.
272 -- N must be at least zero.
273 -- Unchanged on exit.
274 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
275 -- ( 1 + ( n - 1 )*abs( INCX ) )
276 -- Unchanged on exit.
277 -- INCX - INTEGER.
278 -- On entry, INCX specifies the increment for the elements of
279 -- X. INCX must not be zero.
280 -- Unchanged on exit.
281
282 FUNCTION blas_asum(n IN POSITIVEN,
283 x IN utl_nla_array_dbl,
284 incx IN POSITIVEN) RETURN BINARY_DOUBLE;
285
286 FUNCTION blas_asum(n IN POSITIVEN,
287 x IN UTL_NLA_ARRAY_FLT,
288 incx IN POSITIVEN) RETURN BINARY_FLOAT;
289
290 -- Purpose
291 -- =======
292 --
293 -- BLAS_IAMAX computes the index of first element of a vector that has the
294 -- largest absolute value.
295 --
296 -- Arguments
297 -- =========
298 --
299 -- N - INTEGER.
300 -- On entry, N specifies the number of elements of the vectors X and Y.
301 -- N must be at least zero.
302 -- Unchanged on exit.
303 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
304 -- ( 1 + ( n - 1 )*abs( INCX ) )
305 -- Unchanged on exit.
306 -- INCX - INTEGER.
307 -- On entry, INCX specifies the increment for the elements of
308 -- X. INCX must not be zero.
309 -- Unchanged on exit.
310
311 FUNCTION blas_iamax(n IN POSITIVEN,
312 x IN utl_nla_array_dbl,
313 incx IN POSITIVEN) RETURN POSITIVEN;
314
315 FUNCTION blas_iamax(n IN POSITIVEN,
316 x IN UTL_NLA_ARRAY_FLT,
317 incx IN POSITIVEN) RETURN POSITIVEN;
318
319 -- Purpose
320 -- =======
321 --
322 -- BLAS_ROT returns the Plane rotation of points
323 --
324 -- Arguments
325 -- =========
326 --
327 -- N - INTEGER.
328 -- On entry, N specifies the number of elements of the vectors X and Y.
329 -- N must be at least zero.
330 -- Unchanged on exit.
331 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
332 -- ( 1 + ( n - 1 )*abs( INCX ) )
333 -- INCX - INTEGER.
334 -- On entry, INCX specifies the increment for the elements of
335 -- X. INCX must not be zero.
336 -- Unchanged on exit.
337 -- Y - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
338 -- ( 1 + ( n - 1 )*abs( INCY ) )
339 -- INCY - INTEGER.
340 -- On entry, INCY specifies the increment for the elements of
341 -- Y. INCY must not be zero.
342 -- Unchanged on exit.
343 -- C - SCALAR_FLOAT/DOUBLE .
344 -- On entry, C specifies the scalar C.
345 -- Unchanged on exit.
346 -- S - SCALAR_FLOAT/DOUBLE .
347 -- On entry, S specifies the scalar S.
348 -- Unchanged on exit.
349
350 PROCEDURE blas_rot(n IN POSITIVEN,
351 x IN OUT utl_nla_array_dbl,
352 incx IN POSITIVEN,
353 y IN OUT utl_nla_array_dbl,
354 incy IN POSITIVEN,
358 PROCEDURE blas_rot(n IN POSITIVEN,
355 c IN scalar_double,
356 s IN scalar_double);
357
359 x IN OUT UTL_NLA_ARRAY_FLT,
360 incx IN POSITIVEN,
361 y IN OUT UTL_NLA_ARRAY_FLT,
362 incy IN POSITIVEN,
363 c IN scalar_float,
364 s IN scalar_float);
365
366 -- Purpose
367 -- =======
368 --
369 -- BLAS_ROTG returns the Givens rotation of points
370 --
371 -- Arguments
372 -- =========
373 --
374 -- A - SCALAR_FLOAT/DOUBLE .
375 -- On entry, A specifies the scalar A.
376 -- B - SCALAR_FLOAT/DOUBLE .
377 -- On entry, B specifies the scalar B.
378 -- C - SCALAR_FLOAT/DOUBLE .
379 -- On entry, C specifies the scalar C.
380 -- S - SCALAR_FLOAT/DOUBLE .
381 -- On entry, S specifies the scalar S.
382
383 PROCEDURE blas_rotg(a IN OUT scalar_double,
384 b IN OUT scalar_double,
385 c IN OUT scalar_double,
386 s IN OUT scalar_double);
387
388 PROCEDURE blas_rotg(a IN OUT scalar_float,
389 b IN OUT scalar_float,
390 c IN OUT scalar_float,
391 s IN OUT scalar_float);
392
393 -- --------------------------------------- --
394 -- BLAS Level 2 (Vector-Matrix Operations)
395 -- --------------------------------------- --
396
397 -- Purpose
398 -- =======
399 --
400 -- BLAS_GEMV performs one of the matrix-vector operations
401 -- y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y,
402 -- where alpha and beta are scalars, x and y are vectors and A is an
403 -- m by n matrix.
404 --
405 -- Arguments
406 -- =========
407 --
408 -- TRANS - FLAG.
409 -- On entry, TRANS specifies the operation to be performed as
410 -- follows:
411 -- TRANS = 'N' or 'n' y := alpha*A*x + beta*y.
412 -- TRANS = 'T' or 't' y := alpha*A'*x + beta*y.
413 -- TRANS = 'C' or 'c' y := alpha*A'*x + beta*y.
414 -- Unchanged on exit.
415 -- M - INTEGER.
416 -- On entry, M specifies the number of rows of the matrix A.
417 -- M must be at least zero.
418 -- Unchanged on exit.
419 -- N - INTEGER.
420 -- On entry, N specifies the number of columns of the matrix A.
421 -- N must be at least zero.
422 -- Unchanged on exit.
423 -- ALPHA - SCALAR_FLOAT/DOUBLE .
424 -- On entry, ALPHA specifies the scalar alpha.
425 -- Unchanged on exit.
426 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
427 -- Before entry, the leading m by n part of the array A must
428 -- contain the matrix of coefficients.
429 -- Unchanged on exit.
430 -- LDA - INTEGER.
431 -- On entry, LDA specifies the first dimension of A as declared
432 -- in the calling (sub) program. LDA must be at least
433 -- max( 1, m ).
434 -- Unchanged on exit.
435 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
436 -- ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
437 -- and at least
438 -- ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
439 -- Before entry, the incremented array X must contain the
440 -- vector x.
441 -- Unchanged on exit.
442 -- INCX - INTEGER.
443 -- On entry, INCX specifies the increment for the elements of
444 -- X. INCX must not be zero.
445 -- Unchanged on exit.
446 -- BETA - SCALAR_FLOAT/DOUBLE .
447 -- On entry, BETA specifies the scalar beta. When BETA is
448 -- supplied as zero then Y need not be set on input.
449 -- Unchanged on exit.
450 -- Y - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
451 -- ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
452 -- and at least
453 -- ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
454 -- Before entry with BETA non-zero, the incremented array Y
455 -- must contain the vector y. On exit, Y is overwritten by the
456 -- updated vector y.
457 -- INCY - INTEGER.
458 -- On entry, INCY specifies the increment for the elements of
459 -- Y. INCY must not be zero.
460 -- Unchanged on exit.
461 -- PACK - (optional) FLAG
462 -- The packing of the matricies:
463 -- 'C': column-major (default)
464 -- 'R': row-major
465
466 PROCEDURE blas_gemv(trans IN flag,
467 m IN POSITIVEN,
468 n IN POSITIVEN,
469 alpha IN scalar_double,
470 a IN utl_nla_array_dbl,
471 lda IN POSITIVEN,
472 x IN utl_nla_array_dbl,
473 incx IN POSITIVEN,
474 beta IN scalar_double,
475 y IN OUT utl_nla_array_dbl,
476 incy IN POSITIVEN,
480 m IN POSITIVEN,
477 pack IN flag DEFAULT 'C');
478
479 PROCEDURE blas_gemv(trans IN flag,
481 n IN POSITIVEN,
482 alpha IN scalar_float,
483 a IN UTL_NLA_ARRAY_FLT,
484 lda IN POSITIVEN,
485 x IN UTL_NLA_ARRAY_FLT,
486 incx IN POSITIVEN,
487 beta IN scalar_float,
488 y IN OUT UTL_NLA_ARRAY_FLT,
489 incy IN POSITIVEN,
490 pack IN flag DEFAULT 'C');
491
492 -- Purpose
493 -- =======
494 --
495 -- BLAS_GBMV performs one of the matrix-vector operations
496 -- y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y,
497 -- where alpha and beta are scalars, x and y are vectors and A is an
498 -- m by n band matrix, with kl sub-diagonals and ku super-diagonals.
499 --
500 -- Arguments
501 -- =========
502 --
503 -- TRANS - FLAG.
504 -- On entry, TRANS specifies the operation to be performed as
505 -- follows:
506 -- TRANS = 'N' or 'n' y := alpha*A*x + beta*y.
507 -- TRANS = 'T' or 't' y := alpha*A'*x + beta*y.
508 -- TRANS = 'C' or 'c' y := alpha*A'*x + beta*y.
509 -- Unchanged on exit.
510 -- M - INTEGER.
511 -- On entry, M specifies the number of rows of the matrix A.
512 -- M must be at least zero.
513 -- Unchanged on exit.
514 -- N - INTEGER.
515 -- On entry, N specifies the number of columns of the matrix A.
516 -- N must be at least zero.
517 -- Unchanged on exit.
518 -- KL - INTEGER.
519 -- On entry, KL specifies the number of sub-diagonals of the
520 -- matrix A. KL must satisfy 0 .le. KL.
521 -- Unchanged on exit.
522 -- KU - INTEGER.
523 -- On entry, KU specifies the number of super-diagonals of the
524 -- matrix A. KU must satisfy 0 .le. KU.
525 -- Unchanged on exit.
526 -- ALPHA - SCALAR_FLOAT/DOUBLE .
527 -- On entry, ALPHA specifies the scalar alpha.
528 -- Unchanged on exit.
529 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
530 -- Before entry, the leading ( kl + ku + 1 ) by n part of the
531 -- array A must contain the matrix of coefficients, supplied
532 -- column by column, with the leading diagonal of the matrix in
533 -- row ( ku + 1 ) of the array, the first super-diagonal
534 -- starting at position 2 in row ku, the first sub-diagonal
535 -- starting at position 1 in row ( ku + 2 ), and so on.
536 -- Elements in the array A that do not correspond to elements
537 -- in the band matrix (such as the top left ku by ku triangle)
538 -- are not referenced.
539 -- Unchanged on exit.
540 -- LDA - INTEGER.
541 -- On entry, LDA specifies the first dimension of A as declared
542 -- in the calling (sub) program. LDA must be at least
543 -- ( kl + ku + 1 ).
544 -- Unchanged on exit.
545 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
546 -- ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
547 -- and at least
548 -- ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
549 -- Before entry, the incremented array X must contain the
550 -- vector x.
551 -- Unchanged on exit.
552 -- INCX - INTEGER.
553 -- On entry, INCX specifies the increment for the elements of
554 -- X. INCX must not be zero.
555 -- Unchanged on exit.
556 -- BETA - SCALAR_FLOAT/DOUBLE .
557 -- On entry, BETA specifies the scalar beta. When BETA is
558 -- supplied as zero then Y need not be set on input.
559 -- Unchanged on exit.
560 -- Y - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
561 -- ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
562 -- and at least
563 -- ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
564 -- Before entry, the incremented array Y must contain the
565 -- vector y. On exit, Y is overwritten by the updated vector y.
566 -- INCY - INTEGER.
567 -- On entry, INCY specifies the increment for the elements of
568 -- Y. INCY must not be zero.
569 -- Unchanged on exit.
570 -- PACK - (optional) FLAG
571 -- The packing of the matricies:
572 -- 'C': column-major (default)
573 -- 'R': row-major
574
575 PROCEDURE blas_gbmv(trans IN flag,
576 m IN POSITIVEN,
577 n IN POSITIVEN,
578 kl IN NATURALN,
579 ku IN NATURALN,
580 alpha IN scalar_double,
581 a IN utl_nla_array_dbl,
582 lda IN POSITIVEN,
583 x IN utl_nla_array_dbl,
584 incx IN POSITIVEN,
585 beta IN scalar_double,
586 y IN OUT utl_nla_array_dbl,
587 incy IN POSITIVEN,
591 m IN POSITIVEN,
588 pack IN flag DEFAULT 'C');
589
590 PROCEDURE blas_gbmv(trans IN flag,
592 n IN POSITIVEN,
593 kl IN NATURALN,
594 ku IN NATURALN,
595 alpha IN scalar_float,
596 a IN UTL_NLA_ARRAY_FLT,
597 lda IN POSITIVEN,
598 x IN UTL_NLA_ARRAY_FLT,
599 incx IN POSITIVEN,
600 beta IN scalar_float,
601 y IN OUT UTL_NLA_ARRAY_FLT,
602 incy IN POSITIVEN,
603 pack IN flag DEFAULT 'C');
604
605 -- Purpose
606 -- =======
607 --
608 -- BLAS_SYMV performs the matrix-vector operation
609 -- y := alpha*A*x + beta*y,
610 -- where alpha and beta are scalars, x and y are n element vectors and
611 -- A is an n by n symmetric matrix.
612 --
613 -- Arguments
614 -- =========
615 --
616 -- UPLO - FLAG.
617 -- On entry, UPLO specifies whether the upper or lower
618 -- triangular part of the array A is to be referenced as
619 -- follows:
620 -- UPLO = 'U' or 'u' Only the upper triangular part of A
621 -- is to be referenced.
622 -- UPLO = 'L' or 'l' Only the lower triangular part of A
623 -- is to be referenced.
624 -- Unchanged on exit.
625 -- N - INTEGER.
626 -- On entry, N specifies the order of the matrix A.
627 -- N must be at least zero.
628 -- Unchanged on exit.
629 -- ALPHA - SCALAR_FLOAT/DOUBLE .
630 -- On entry, ALPHA specifies the scalar alpha.
631 -- Unchanged on exit.
632 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
633 -- Before entry with UPLO = 'U' or 'u', the leading n by n
634 -- upper triangular part of the array A must contain the upper
635 -- triangular part of the symmetric matrix and the strictly
636 -- lower triangular part of A is not referenced.
637 -- Before entry with UPLO = 'L' or 'l', the leading n by n
638 -- lower triangular part of the array A must contain the lower
639 -- triangular part of the symmetric matrix and the strictly
640 -- upper triangular part of A is not referenced.
641 -- Unchanged on exit.
642 -- LDA - INTEGER.
643 -- On entry, LDA specifies the first dimension of A as declared
644 -- in the calling (sub) program. LDA must be at least
645 -- max( 1, n ).
646 -- Unchanged on exit.
647 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
648 -- ( 1 + ( n - 1 )*abs( INCX ) ).
649 -- Before entry, the incremented array X must contain the n
650 -- element vector x.
651 -- Unchanged on exit.
652 -- INCX - INTEGER.
653 -- On entry, INCX specifies the increment for the elements of
654 -- X. INCX must not be zero.
655 -- Unchanged on exit.
656 -- BETA - SCALAR_FLOAT/DOUBLE .
657 -- On entry, BETA specifies the scalar beta. When BETA is
658 -- supplied as zero then Y need not be set on input.
659 -- Unchanged on exit.
660 -- Y - UTL_NLA_ARRAY_FLT/DBL of dimension at least
661 -- ( 1 + ( n - 1 )*abs( INCY ) ).
662 -- Before entry, the incremented array Y must contain the n
663 -- element vector y. On exit, Y is overwritten by the updated
664 -- vector y.
665 -- INCY - INTEGER.
666 -- On entry, INCY specifies the increment for the elements of
667 -- Y. INCY must not be zero.
668 -- Unchanged on exit.
669 -- PACK - (optional) FLAG
670 -- The packing of the matricies:
671 -- 'C': column-major (default)
672 -- 'R': row-major
673
674 PROCEDURE blas_symv(uplo IN flag,
675 n IN POSITIVEN,
676 alpha IN scalar_double,
677 a IN utl_nla_array_dbl,
678 lda IN POSITIVEN,
679 x IN utl_nla_array_dbl,
680 incx IN POSITIVEN,
681 beta IN scalar_double,
682 y IN OUT utl_nla_array_dbl,
683 incy IN POSITIVEN,
684 pack IN flag DEFAULT 'C');
685
686 PROCEDURE blas_symv(uplo IN flag,
687 n IN POSITIVEN,
688 alpha IN scalar_float,
689 a IN UTL_NLA_ARRAY_FLT,
690 lda IN POSITIVEN,
691 x IN UTL_NLA_ARRAY_FLT,
692 incx IN POSITIVEN,
693 beta IN scalar_float,
694 y IN OUT UTL_NLA_ARRAY_FLT,
695 incy IN POSITIVEN,
696 pack IN flag DEFAULT 'C');
697
698 -- Purpose
699 -- =======
700 --
701 -- SSBMV performs the matrix-vector operation
705 --
702 -- y := alpha*A*x + beta*y,
703 -- where alpha and beta are scalars, x and y are n element vectors and
704 -- A is an n by n symmetric band matrix, with k super-diagonals.
706 -- Parameters
707 -- ==========
708 --
709 -- UPLO - FLAG.
710 -- On entry, UPLO specifies whether the upper or lower
711 -- triangular part of the band matrix A is being supplied as
712 -- follows:
713 -- UPLO = 'U' or 'u' The upper triangular part of A is
714 -- being supplied.
715 -- UPLO = 'L' or 'l' The lower triangular part of A is
716 -- being supplied.
717 -- Unchanged on exit.
718 -- N - INTEGER.
719 -- On entry, N specifies the order of the matrix A.
720 -- N must be at least zero.
721 -- Unchanged on exit.
722 -- K - INTEGER.
723 -- On entry, K specifies the number of super-diagonals of the
724 -- matrix A. K must satisfy 0 .le. K.
725 -- Unchanged on exit.
726 -- ALPHA - SCALAR_FLOAT/DOUBLE .
727 -- On entry, ALPHA specifies the scalar alpha.
728 -- Unchanged on exit.
729 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
730 -- Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
731 -- by n part of the array A must contain the upper triangular
732 -- band part of the symmetric matrix, supplied column by
733 -- column, with the leading diagonal of the matrix in row
734 -- ( k + 1 ) of the array, the first super-diagonal starting at
735 -- position 2 in row k, and so on. The top left k by k triangle
736 -- of the array A is not referenced.
737 -- Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
738 -- by n part of the array A must contain the lower triangular
739 -- band part of the symmetric matrix, supplied column by
740 -- column, with the leading diagonal of the matrix in row 1 of
741 -- the array, the first sub-diagonal starting at position 1 in
742 -- row 2, and so on. The bottom right k by k triangle of the
743 -- array A is not referenced.
744 -- Unchanged on exit.
745 -- LDA - INTEGER.
746 -- On entry, LDA specifies the first dimension of A as declared
747 -- in the calling (sub) program. LDA must be at least
748 -- ( k + 1 ).
749 -- Unchanged on exit.
750 -- X - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
751 -- ( 1 + ( n - 1 )*abs( INCX ) ).
752 -- Before entry, the incremented array X must contain the
753 -- vector x.
754 -- Unchanged on exit.
755 -- INCX - INTEGER.
756 -- On entry, INCX specifies the increment for the elements of
757 -- X. INCX must not be zero.
758 -- Unchanged on exit.
759 -- BETA - SCALAR_FLOAT/DOUBLE .
760 -- On entry, BETA specifies the scalar beta.
761 -- Unchanged on exit.
762 -- Y - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
763 -- ( 1 + ( n - 1 )*abs( INCY ) ).
764 -- Before entry, the incremented array Y must contain the
765 -- vector y. On exit, Y is overwritten by the updated vector y.
766 -- INCY - INTEGER.
767 -- On entry, INCY specifies the increment for the elements of
768 -- Y. INCY must not be zero.
769 -- Unchanged on exit.
770 -- PACK - (optional) FLAG
771 -- The packing of the matricies:
772 -- 'C': column-major (default)
773 -- 'R': row-major
774
775 PROCEDURE blas_sbmv(uplo IN flag,
776 n IN POSITIVEN,
777 k IN NATURALN,
778 alpha IN scalar_double,
779 a IN utl_nla_array_dbl,
780 lda IN POSITIVEN,
781 x IN utl_nla_array_dbl,
782 incx IN POSITIVEN,
783 beta IN scalar_double,
784 y IN OUT utl_nla_array_dbl,
785 incy IN POSITIVEN,
786 pack IN flag DEFAULT 'C');
787
788 PROCEDURE blas_sbmv(uplo IN flag,
789 n IN POSITIVEN,
790 k IN NATURALN,
791 alpha IN scalar_float,
792 a IN UTL_NLA_ARRAY_FLT,
793 lda IN POSITIVEN,
794 x IN UTL_NLA_ARRAY_FLT,
795 incx IN POSITIVEN,
796 beta IN scalar_float,
797 y IN OUT UTL_NLA_ARRAY_FLT,
798 incy IN POSITIVEN,
799 pack IN flag DEFAULT 'C');
800
801 -- Purpose
802 -- =======
803 --
804 -- BLAS_SPMV performs the matrix-vector operation
805 -- y := alpha*A*x + beta*y,
806 -- where alpha and beta are scalars, x and y are n element vectors and
807 -- A is an n by n symmetric matrix, supplied in packed form.
808 --
809 -- Parameters
810 -- ==========
811 --
812 -- UPLO - FLAG.
813 -- On entry, UPLO specifies whether the upper or lower
817 -- supplied in AP.
814 -- triangular part of the matrix A is supplied in the packed
815 -- array AP as follows:
816 -- UPLO = 'U' or 'u' The upper triangular part of A is
818 -- UPLO = 'L' or 'l' The lower triangular part of A is
819 -- supplied in AP.
820 -- Unchanged on exit.
821 -- N - INTEGER.
822 -- On entry, N specifies the order of the matrix A.
823 -- N must be at least zero.
824 -- Unchanged on exit.
825 -- ALPHA - SCALAR_FLOAT/DOUBLE .
826 -- On entry, ALPHA specifies the scalar alpha.
827 -- Unchanged on exit.
828 -- AP - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
829 -- ( ( n*( n + 1 ) )/2 ).
830 -- Before entry with UPLO = 'U' or 'u', the array AP must
831 -- contain the upper triangular part of the symmetric matrix
832 -- packed sequentially, column by column, so that AP( 1 )
833 -- contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 )
834 -- and a( 2, 2 ) respectively, and so on.
835 -- Before entry with UPLO = 'L' or 'l', the array AP must
836 -- contain the lower triangular part of the symmetric matrix
837 -- packed sequentially, column by column, so that AP( 1 )
838 -- contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 )
839 -- and a( 3, 1 ) respectively, and so on.
840 -- Unchanged on exit.
841 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
842 -- ( 1 + ( n - 1 )*abs( INCX ) ).
843 -- Before entry, the incremented array X must contain the n
844 -- element vector x.
845 -- Unchanged on exit.
846 -- INCX - INTEGER.
847 -- On entry, INCX specifies the increment for the elements of
848 -- X. INCX must not be zero.
849 -- Unchanged on exit.
850 -- BETA - SCALAR_FLOAT/DOUBLE .
851 -- On entry, BETA specifies the scalar beta. When BETA is
852 -- supplied as zero then Y need not be set on input.
853 -- Unchanged on exit.
854 -- Y - UTL_NLA_ARRAY_FLT/DBL of dimension at least
855 -- ( 1 + ( n - 1 )*abs( INCY ) ).
856 -- Before entry, the incremented array Y must contain the n
857 -- element vector y. On exit, Y is overwritten by the updated
858 -- vector y.
859 -- INCY - INTEGER.
860 -- On entry, INCY specifies the increment for the elements of
861 -- Y. INCY must not be zero.
862 -- Unchanged on exit.
863 -- PACK - (optional) FLAG
864 -- The packing of the matricies:
865 -- 'C': column-major (default)
866 -- 'R': row-major
867
868 PROCEDURE blas_spmv(uplo IN flag,
869 n IN POSITIVEN,
870 alpha IN scalar_double,
871 ap IN utl_nla_array_dbl,
872 x IN utl_nla_array_dbl,
873 incx IN POSITIVEN,
874 beta IN scalar_double,
875 y IN OUT utl_nla_array_dbl,
876 incy IN POSITIVEN,
877 pack IN flag DEFAULT 'C');
878
879 PROCEDURE blas_spmv(uplo IN flag,
880 n IN POSITIVEN,
881 alpha IN scalar_float,
882 ap IN UTL_NLA_ARRAY_FLT,
883 x IN UTL_NLA_ARRAY_FLT,
884 incx IN POSITIVEN,
885 beta IN scalar_float,
886 y IN OUT UTL_NLA_ARRAY_FLT,
887 incy IN POSITIVEN,
888 pack IN flag DEFAULT 'C');
889
890 -- Purpose
891 -- =======
892 --
893 -- BLAS_TRMV performs one of the matrix-vector operations
894 -- x := A*x, or x := A'*x,
895 -- where x is an n element vector and A is an n by n unit, or non-unit,
896 -- upper or lower triangular matrix.
897 --
898 -- Parameters
899 -- ==========
900 --
901 -- UPLO - FLAG.
902 -- On entry, UPLO specifies whether the matrix is an upper or
903 -- lower triangular matrix as follows:
904 -- UPLO = 'U' or 'u' A is an upper triangular matrix.
905 -- UPLO = 'L' or 'l' A is a lower triangular matrix.
906 -- Unchanged on exit.
907 -- TRANS - FLAG.
908 -- On entry, TRANS specifies the operation to be performed as
909 -- follows:
910 -- TRANS = 'N' or 'n' x := A*x.
911 -- TRANS = 'T' or 't' x := A'*x.
912 -- TRANS = 'C' or 'c' x := A'*x.
913 -- Unchanged on exit.
914 -- DIAG - FLAG.
915 -- On entry, DIAG specifies whether or not A is unit
916 -- triangular as follows:
917 -- DIAG = 'U' or 'u' A is assumed to be unit triangular.
918 -- DIAG = 'N' or 'n' A is not assumed to be unit
919 -- triangular.
920 -- Unchanged on exit.
921 -- N - INTEGER.
922 -- On entry, N specifies the order of the matrix A.
923 -- N must be at least zero.
924 -- Unchanged on exit.
928 -- triangular matrix and the strictly lower triangular part of
925 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
926 -- Before entry with UPLO = 'U' or 'u', the leading n by n
927 -- upper triangular part of the array A must contain the upper
929 -- A is not referenced.
930 -- Before entry with UPLO = 'L' or 'l', the leading n by n
931 -- lower triangular part of the array A must contain the lower
932 -- triangular matrix and the strictly upper triangular part of
933 -- A is not referenced.
934 -- Note that when DIAG = 'U' or 'u', the diagonal elements of
935 -- A are not referenced either, but are assumed to be unity.
936 -- Unchanged on exit.
937 -- LDA - INTEGER.
938 -- On entry, LDA specifies the first dimension of A as declared
939 -- in the calling (sub) program. LDA must be at least
940 -- max( 1, n ).
941 -- Unchanged on exit.
942 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
943 -- ( 1 + ( n - 1 )*abs( INCX ) ).
944 -- Before entry, the incremented array X must contain the n
945 -- element vector x. On exit, X is overwritten with the
946 -- tranformed vector x.
947 -- INCX - INTEGER.
948 -- On entry, INCX specifies the increment for the elements of
949 -- X. INCX must not be zero.
950 -- Unchanged on exit.
951 -- PACK - (optional) FLAG
952 -- The packing of the matricies:
953 -- 'C': column-major (default)
954 -- 'R': row-major
955
956 PROCEDURE blas_trmv(uplo IN flag,
957 trans IN flag,
958 diag IN flag,
959 n IN POSITIVEN,
960 a IN utl_nla_array_dbl,
961 lda IN POSITIVEN,
962 x IN OUT utl_nla_array_dbl,
963 incx IN POSITIVEN,
964 pack IN flag DEFAULT 'C');
965
966 PROCEDURE blas_trmv(uplo IN flag,
967 trans IN flag,
968 diag IN flag,
969 n IN POSITIVEN,
970 a IN UTL_NLA_ARRAY_FLT,
971 lda IN POSITIVEN,
972 x IN OUT UTL_NLA_ARRAY_FLT,
973 incx IN POSITIVEN,
974 pack IN flag DEFAULT 'C');
975
976 -- Purpose
977 -- =======
978 --
979 -- BLAS_TBMV performs one of the matrix-vector operations
980 -- x := A*x, or x := A'*x,
981 -- where x is an n element vector and A is an n by n unit, or non-unit,
982 -- upper or lower triangular band matrix, with ( k + 1 ) diagonals.
983 --
984 -- Arguments
985 -- =========
986 --
987 -- UPLO - FLAG.
988 -- On entry, UPLO specifies whether the matrix is an upper or
989 -- lower triangular matrix as follows:
990 -- UPLO = 'U' or 'u' A is an upper triangular matrix.
991 -- UPLO = 'L' or 'l' A is a lower triangular matrix.
992 -- Unchanged on exit.
993 -- TRANS - FLAG.
994 -- On entry, TRANS specifies the operation to be performed as
995 -- follows:
996 -- TRANS = 'N' or 'n' x := A*x.
997 -- TRANS = 'T' or 't' x := A'*x.
998 -- TRANS = 'C' or 'c' x := A'*x.
999 -- Unchanged on exit.
1000 -- DIAG - FLAG.
1001 -- On entry, DIAG specifies whether or not A is unit
1002 -- triangular as follows:
1003 -- DIAG = 'U' or 'u' A is assumed to be unit triangular.
1004 -- DIAG = 'N' or 'n' A is not assumed to be unit
1005 -- triangular.
1006 -- Unchanged on exit.
1007 -- N - INTEGER.
1008 -- On entry, N specifies the order of the matrix A.
1009 -- N must be at least zero.
1010 -- Unchanged on exit.
1011 -- K - INTEGER.
1012 -- On entry with UPLO = 'U' or 'u', K specifies the number of
1013 -- super-diagonals of the matrix A.
1014 -- On entry with UPLO = 'L' or 'l', K specifies the number of
1015 -- sub-diagonals of the matrix A.
1016 -- K must satisfy 0 .le. K.
1017 -- Unchanged on exit.
1018 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
1019 -- Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
1020 -- by n part of the array A must contain the upper triangular
1021 -- band part of the matrix of coefficients, supplied column by
1022 -- column, with the leading diagonal of the matrix in row
1023 -- ( k + 1 ) of the array, the first super-diagonal starting at
1024 -- position 2 in row k, and so on. The top left k by k triangle
1025 -- of the array A is not referenced.
1026 -- Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
1027 -- by n part of the array A must contain the lower triangular
1028 -- band part of the matrix of coefficients, supplied column by
1029 -- column, with the leading diagonal of the matrix in row 1 of
1030 -- the array, the first sub-diagonal starting at position 1 in
1031 -- row 2, and so on. The bottom right k by k triangle of the
1035 -- referenced, but are assumed to be unity.
1032 -- array A is not referenced.
1033 -- Note that when DIAG = 'U' or 'u' the elements of the array A
1034 -- corresponding to the diagonal elements of the matrix are not
1036 -- Unchanged on exit.
1037 -- LDA - INTEGER.
1038 -- On entry, LDA specifies the first dimension of A as declared
1039 -- in the calling (sub) program. LDA must be at least
1040 -- ( k + 1 ).
1041 -- Unchanged on exit.
1042 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1043 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1044 -- Before entry, the incremented array X must contain the n
1045 -- element vector x. On exit, X is overwritten with the
1046 -- tranformed vector x.
1047 -- INCX - INTEGER.
1048 -- On entry, INCX specifies the increment for the elements of
1049 -- X. INCX must not be zero.
1050 -- Unchanged on exit.
1051 -- PACK - (optional) FLAG
1052 -- The packing of the matricies:
1053 -- 'C': column-major (default)
1054 -- 'R': row-major
1055
1056 PROCEDURE blas_tbmv(uplo IN flag,
1057 trans IN flag,
1058 diag IN flag,
1059 n IN POSITIVEN,
1060 k IN NATURALN,
1061 a IN utl_nla_array_dbl,
1062 lda IN POSITIVEN,
1063 x IN OUT utl_nla_array_dbl,
1064 incx IN POSITIVEN,
1065 pack IN flag DEFAULT 'C');
1066
1067 PROCEDURE blas_tbmv(uplo IN flag,
1068 trans IN flag,
1069 diag IN flag,
1070 n IN POSITIVEN,
1071 k IN NATURALN,
1072 a IN UTL_NLA_ARRAY_FLT,
1073 lda IN POSITIVEN,
1074 x IN OUT UTL_NLA_ARRAY_FLT,
1075 incx IN POSITIVEN,
1076 pack IN flag DEFAULT 'C');
1077
1078 -- Purpose
1079 -- =======
1080 --
1081 -- BLAS_TPMV performs one of the matrix-vector operations
1082 -- x := A*x, or x := A'*x,
1083 -- where x is an n element vector and A is an n by n unit, or non-unit,
1084 -- upper or lower triangular matrix, supplied in packed form.
1085 --
1086 -- Parameters
1087 -- ==========
1088 --
1089 -- UPLO - FLAG.
1090 -- On entry, UPLO specifies whether the matrix is an upper or
1091 -- lower triangular matrix as follows:
1092 -- UPLO = 'U' or 'u' A is an upper triangular matrix.
1093 -- UPLO = 'L' or 'l' A is a lower triangular matrix.
1094 -- Unchanged on exit.
1095 -- TRANS - FLAG.
1096 -- On entry, TRANS specifies the operation to be performed as
1097 -- follows:
1098 -- TRANS = 'N' or 'n' x := A*x.
1099 -- TRANS = 'T' or 't' x := A'*x.
1100 -- TRANS = 'C' or 'c' x := A'*x.
1101 -- Unchanged on exit.
1102 -- DIAG - FLAG.
1103 -- On entry, DIAG specifies whether or not A is unit
1104 -- triangular as follows:
1105 -- DIAG = 'U' or 'u' A is assumed to be unit triangular.
1106 -- DIAG = 'N' or 'n' A is not assumed to be unit
1107 -- triangular.
1108 -- Unchanged on exit.
1109 -- N - INTEGER.
1110 -- On entry, N specifies the order of the matrix A.
1111 -- N must be at least zero.
1112 -- Unchanged on exit.
1113 -- AP - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
1114 -- ( ( n*( n + 1 ) )/2 ).
1115 -- Before entry with UPLO = 'U' or 'u', the array AP must
1116 -- contain the upper triangular matrix packed sequentially,
1117 -- column by column, so that AP( 1 ) contains a( 1, 1 ),
1118 -- AP( 2 ) and AP( 3 ) contain a( 1, 2 ) and a( 2, 2 )
1119 -- respectively, and so on.
1120 -- Before entry with UPLO = 'L' or 'l', the array AP must
1121 -- contain the lower triangular matrix packed sequentially,
1122 -- column by column, so that AP( 1 ) contains a( 1, 1 ),
1123 -- AP( 2 ) and AP( 3 ) contain a( 2, 1 ) and a( 3, 1 )
1124 -- respectively, and so on.
1125 -- Note that when DIAG = 'U' or 'u', the diagonal elements of
1126 -- A are not referenced, but are assumed to be unity.
1127 -- Unchanged on exit.
1128 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1129 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1130 -- Before entry, the incremented array X must contain the n
1131 -- element vector x. On exit, X is overwritten with the
1132 -- tranformed vector x.
1133 -- INCX - INTEGER.
1134 -- On entry, INCX specifies the increment for the elements of
1135 -- X. INCX must not be zero.
1136 -- Unchanged on exit.
1137 -- PACK - (optional) FLAG
1138 -- The packing of the matricies:
1139 -- 'C': column-major (default)
1140 -- 'R': row-major
1141
1142 PROCEDURE blas_tpmv(uplo IN flag,
1143 trans IN flag,
1144 diag IN flag,
1148 incx IN POSITIVEN,
1145 n IN POSITIVEN,
1146 ap IN utl_nla_array_dbl,
1147 x IN OUT utl_nla_array_dbl,
1149 pack IN flag DEFAULT 'C');
1150
1151 PROCEDURE blas_tpmv(uplo IN flag,
1152 trans IN flag,
1153 diag IN flag,
1154 n IN POSITIVEN,
1155 ap IN UTL_NLA_ARRAY_FLT,
1156 x IN OUT UTL_NLA_ARRAY_FLT,
1157 incx IN POSITIVEN,
1158 pack IN flag DEFAULT 'C');
1159
1160 -- Purpose
1161 -- =======
1162 --
1163 -- BLAS_TRSV solves one of the systems of equations
1164 -- A*x = b, or A'*x = b,
1165 -- where b and x are n element vectors and A is an n by n unit, or
1166 -- non-unit, upper or lower triangular matrix.
1167 -- No test for singularity or near-singularity is included in this
1168 -- routine. Such tests must be performed before calling this routine.
1169 --
1170 -- Arguments
1171 -- =========
1172 --
1173 -- UPLO - FLAG.
1174 -- On entry, UPLO specifies whether the matrix is an upper or
1175 -- lower triangular matrix as follows:
1176 -- UPLO = 'U' or 'u' A is an upper triangular matrix.
1177 -- UPLO = 'L' or 'l' A is a lower triangular matrix.
1178 -- Unchanged on exit.
1179 -- TRANS - FLAG.
1180 -- On entry, TRANS specifies the equations to be solved as
1181 -- follows:
1182 -- TRANS = 'N' or 'n' A*x = b.
1183 -- TRANS = 'T' or 't' A'*x = b.
1184 -- TRANS = 'C' or 'c' A'*x = b.
1185 -- Unchanged on exit.
1186 -- DIAG - FLAG.
1187 -- On entry, DIAG specifies whether or not A is unit
1188 -- triangular as follows:
1189 -- DIAG = 'U' or 'u' A is assumed to be unit triangular.
1190 -- DIAG = 'N' or 'n' A is not assumed to be unit
1191 -- triangular.
1192 -- Unchanged on exit.
1193 -- N - INTEGER.
1194 -- On entry, N specifies the order of the matrix A.
1195 -- N must be at least zero.
1196 -- Unchanged on exit.
1197 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
1198 -- Before entry with UPLO = 'U' or 'u', the leading n by n
1199 -- upper triangular part of the array A must contain the upper
1200 -- triangular matrix and the strictly lower triangular part of
1201 -- A is not referenced.
1202 -- Before entry with UPLO = 'L' or 'l', the leading n by n
1203 -- lower triangular part of the array A must contain the lower
1204 -- triangular matrix and the strictly upper triangular part of
1205 -- A is not referenced.
1206 -- Note that when DIAG = 'U' or 'u', the diagonal elements of
1207 -- A are not referenced either, but are assumed to be unity.
1208 -- Unchanged on exit.
1209 -- LDA - INTEGER.
1210 -- On entry, LDA specifies the first dimension of A as declared
1211 -- in the calling (sub) program. LDA must be at least
1212 -- max( 1, n ).
1213 -- Unchanged on exit.
1214 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1215 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1216 -- Before entry, the incremented array X must contain the n
1217 -- element right-hand side vector b. On exit, X is overwritten
1218 -- with the solution vector x.
1219 -- INCX - INTEGER.
1220 -- On entry, INCX specifies the increment for the elements of
1221 -- X. INCX must not be zero.
1222 -- Unchanged on exit.
1223 -- PACK - (optional) FLAG
1224 -- The packing of the matricies:
1225 -- 'C': column-major (default)
1226 -- 'R': row-major
1227
1228 PROCEDURE blas_trsv(uplo IN flag,
1229 trans IN flag,
1230 diag IN flag,
1231 n IN POSITIVEN,
1232 a IN utl_nla_array_dbl,
1233 lda IN POSITIVEN,
1234 x IN OUT utl_nla_array_dbl,
1235 incx IN POSITIVEN,
1236 pack IN flag DEFAULT 'C');
1237
1238 PROCEDURE blas_trsv(uplo IN flag,
1239 trans IN flag,
1240 diag IN flag,
1241 n IN POSITIVEN,
1242 a IN UTL_NLA_ARRAY_FLT,
1243 lda IN POSITIVEN,
1244 x IN OUT UTL_NLA_ARRAY_FLT,
1245 incx IN POSITIVEN,
1246 pack IN flag DEFAULT 'C');
1247
1248 -- Purpose
1249 -- =======
1250 --
1251 -- STBSV solves one of the systems of equations
1252 -- A*x = b, or A'*x = b,
1253 -- where b and x are n element vectors and A is an n by n unit, or
1254 -- non-unit, upper or lower triangular band matrix, with ( k + 1 )
1255 -- diagonals.
1256 -- No test for singularity or near-singularity is included in this
1257 -- routine. Such tests must be performed before calling this routine.
1258 --
1259 -- Parameters
1260 -- ==========
1261 --
1265 -- UPLO = 'U' or 'u' A is an upper triangular matrix.
1262 -- UPLO - FLAG.
1263 -- On entry, UPLO specifies whether the matrix is an upper or
1264 -- lower triangular matrix as follows:
1266 -- UPLO = 'L' or 'l' A is a lower triangular matrix.
1267 -- Unchanged on exit.
1268 -- TRANS - FLAG.
1269 -- On entry, TRANS specifies the equations to be solved as
1270 -- follows:
1271 -- TRANS = 'N' or 'n' A*x = b.
1272 -- TRANS = 'T' or 't' A'*x = b.
1273 -- TRANS = 'C' or 'c' A'*x = b.
1274 -- Unchanged on exit.
1275 -- DIAG - FLAG.
1276 -- On entry, DIAG specifies whether or not A is unit
1277 -- triangular as follows:
1278 -- DIAG = 'U' or 'u' A is assumed to be unit triangular.
1279 -- DIAG = 'N' or 'n' A is not assumed to be unit
1280 -- triangular.
1281 -- Unchanged on exit.
1282 -- N - INTEGER.
1283 -- On entry, N specifies the order of the matrix A.
1284 -- N must be at least zero.
1285 -- Unchanged on exit.
1286 -- K - INTEGER.
1287 -- On entry with UPLO = 'U' or 'u', K specifies the number of
1288 -- super-diagonals of the matrix A.
1289 -- On entry with UPLO = 'L' or 'l', K specifies the number of
1290 -- sub-diagonals of the matrix A.
1291 -- K must satisfy 0 .le. K.
1292 -- Unchanged on exit.
1293 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
1294 -- Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
1295 -- by n part of the array A must contain the upper triangular
1296 -- band part of the matrix of coefficients, supplied column by
1297 -- column, with the leading diagonal of the matrix in row
1298 -- ( k + 1 ) of the array, the first super-diagonal starting at
1299 -- position 2 in row k, and so on. The top left k by k triangle
1300 -- of the array A is not referenced.
1301 -- Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
1302 -- by n part of the array A must contain the lower triangular
1303 -- band part of the matrix of coefficients, supplied column by
1304 -- column, with the leading diagonal of the matrix in row 1 of
1305 -- the array, the first sub-diagonal starting at position 1 in
1306 -- row 2, and so on. The bottom right k by k triangle of the
1307 -- array A is not referenced.
1308 -- Note that when DIAG = 'U' or 'u' the elements of the array A
1309 -- corresponding to the diagonal elements of the matrix are not
1310 -- referenced, but are assumed to be unity.
1311 -- Unchanged on exit.
1312 -- LDA - INTEGER.
1313 -- On entry, LDA specifies the first dimension of A as declared
1314 -- in the calling (sub) program. LDA must be at least
1315 -- ( k + 1 ).
1316 -- Unchanged on exit.
1317 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1318 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1319 -- Before entry, the incremented array X must contain the n
1320 -- element right-hand side vector b. On exit, X is overwritten
1321 -- with the solution vector x.
1322 -- INCX - INTEGER.
1323 -- On entry, INCX specifies the increment for the elements of
1324 -- X. INCX must not be zero.
1325 -- Unchanged on exit.
1326 -- PACK - (optional) FLAG
1327 -- The packing of the matricies:
1328 -- 'C': column-major (default)
1329 -- 'R': row-major
1330
1331 PROCEDURE blas_tbsv(uplo IN flag,
1332 trans IN flag,
1333 diag IN flag,
1334 n IN POSITIVEN,
1335 k IN NATURALN,
1336 a IN utl_nla_array_dbl,
1337 lda IN POSITIVEN,
1338 x IN OUT utl_nla_array_dbl,
1339 incx IN POSITIVEN,
1340 pack IN flag DEFAULT 'C');
1341
1342 PROCEDURE blas_tbsv(uplo IN flag,
1343 trans IN flag,
1344 diag IN flag,
1345 n IN POSITIVEN,
1346 k IN NATURALN,
1347 a IN UTL_NLA_ARRAY_FLT,
1348 lda IN POSITIVEN,
1349 x IN OUT UTL_NLA_ARRAY_FLT,
1350 incx IN POSITIVEN,
1351 pack IN flag DEFAULT 'C');
1352
1353 -- Purpose
1354 -- =======
1355 --
1356 -- BLAS_TPSV solves one of the systems of equations
1357 -- A*x = b, or A'*x = b,
1358 -- where b and x are n element vectors and A is an n by n unit, or
1359 -- non-unit, upper or lower triangular matrix, supplied in packed form.
1360 -- No test for singularity or near-singularity is included in this
1361 -- routine. Such tests must be performed before calling this routine.
1362 --
1363 -- Arguments
1364 -- =========
1365 --
1366 -- UPLO - FLAG.
1367 -- On entry, UPLO specifies whether the matrix is an upper or
1368 -- lower triangular matrix as follows:
1369 -- UPLO = 'U' or 'u' A is an upper triangular matrix.
1373 -- On entry, TRANS specifies the equations to be solved as
1370 -- UPLO = 'L' or 'l' A is a lower triangular matrix.
1371 -- Unchanged on exit.
1372 -- TRANS - FLAG.
1374 -- follows:
1375 -- TRANS = 'N' or 'n' A*x = b.
1376 -- TRANS = 'T' or 't' A'*x = b.
1377 -- TRANS = 'C' or 'c' A'*x = b.
1378 -- Unchanged on exit.
1379 -- DIAG - FLAG.
1380 -- On entry, DIAG specifies whether or not A is unit
1381 -- triangular as follows:
1382 -- DIAG = 'U' or 'u' A is assumed to be unit triangular.
1383 -- DIAG = 'N' or 'n' A is not assumed to be unit
1384 -- triangular.
1385 -- Unchanged on exit.
1386 -- N - INTEGER.
1387 -- On entry, N specifies the order of the matrix A.
1388 -- N must be at least zero.
1389 -- Unchanged on exit.
1390 -- AP - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
1391 -- ( ( n*( n + 1 ) )/2 ).
1392 -- Before entry with UPLO = 'U' or 'u', the array AP must
1393 -- contain the upper triangular matrix packed sequentially,
1394 -- column by column, so that AP( 1 ) contains a( 1, 1 ),
1395 -- AP( 2 ) and AP( 3 ) contain a( 1, 2 ) and a( 2, 2 )
1396 -- respectively, and so on.
1397 -- Before entry with UPLO = 'L' or 'l', the array AP must
1398 -- contain the lower triangular matrix packed sequentially,
1399 -- column by column, so that AP( 1 ) contains a( 1, 1 ),
1400 -- AP( 2 ) and AP( 3 ) contain a( 2, 1 ) and a( 3, 1 )
1401 -- respectively, and so on.
1402 -- Note that when DIAG = 'U' or 'u', the diagonal elements of
1403 -- A are not referenced, but are assumed to be unity.
1404 -- Unchanged on exit.
1405 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1406 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1407 -- Before entry, the incremented array X must contain the n
1408 -- element right-hand side vector b. On exit, X is overwritten
1409 -- with the solution vector x.
1410 -- INCX - INTEGER.
1411 -- On entry, INCX specifies the increment for the elements of
1412 -- X. INCX must not be zero.
1413 -- Unchanged on exit.
1414 -- PACK - (optional) FLAG
1415 -- The packing of the matricies:
1416 -- 'C': column-major (default)
1417 -- 'R': row-major
1418
1419 PROCEDURE blas_tpsv(uplo IN flag,
1420 trans IN flag,
1421 diag IN flag,
1422 n IN POSITIVEN,
1423 ap IN utl_nla_array_dbl,
1424 x IN OUT utl_nla_array_dbl,
1425 incx IN POSITIVEN,
1426 pack IN flag DEFAULT 'C');
1427
1428 PROCEDURE blas_tpsv(uplo IN flag,
1429 trans IN flag,
1430 diag IN flag,
1431 n IN POSITIVEN,
1432 ap IN UTL_NLA_ARRAY_FLT,
1433 x IN OUT UTL_NLA_ARRAY_FLT,
1434 incx IN POSITIVEN,
1435 pack IN flag DEFAULT 'C');
1436
1437 -- Purpose
1438 -- =======
1439 --
1440 -- BLAS_GER performs the rank 1 operation
1441 -- A := alpha*x*y' + A,
1442 -- where alpha is a scalar, x is an m element vector, y is an n element
1443 -- vector and A is an m by n matrix.
1444 --
1445 -- Arguments
1446 -- =========
1447 --
1448 -- M - INTEGER.
1449 -- On entry, M specifies the number of rows of the matrix A.
1450 -- M must be at least zero.
1451 -- Unchanged on exit.
1452 -- N - INTEGER.
1453 -- On entry, N specifies the number of columns of the matrix A.
1454 -- N must be at least zero.
1455 -- Unchanged on exit.
1456 -- ALPHA - SCALAR_FLOAT/DOUBLE .
1457 -- On entry, ALPHA specifies the scalar alpha.
1458 -- Unchanged on exit.
1459 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1460 -- ( 1 + ( m - 1 )*abs( INCX ) ).
1461 -- Before entry, the incremented array X must contain the m
1462 -- element vector x.
1463 -- Unchanged on exit.
1464 -- INCX - INTEGER.
1465 -- On entry, INCX specifies the increment for the elements of
1466 -- X. INCX must not be zero.
1467 -- Unchanged on exit.
1468 -- Y - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1469 -- ( 1 + ( n - 1 )*abs( INCY ) ).
1470 -- Before entry, the incremented array Y must contain the n
1471 -- element vector y.
1472 -- Unchanged on exit.
1473 -- INCY - INTEGER.
1474 -- On entry, INCY specifies the increment for the elements of
1475 -- Y. INCY must not be zero.
1476 -- Unchanged on exit.
1477 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
1478 -- Before entry, the leading m by n part of the array A must
1479 -- contain the matrix of coefficients. On exit, A is
1480 -- overwritten by the updated matrix.
1481 -- LDA - INTEGER.
1482 -- On entry, LDA specifies the first dimension of A as declared
1483 -- in the calling (sub) program. LDA must be at least
1487 -- The packing of the matricies:
1484 -- max( 1, m ).
1485 -- Unchanged on exit.
1486 -- PACK - (optional) FLAG
1488 -- 'C': column-major (default)
1489 -- 'R': row-major
1490
1491 PROCEDURE blas_ger(m IN POSITIVEN,
1492 n IN POSITIVEN,
1493 alpha IN scalar_double,
1494 x IN utl_nla_array_dbl,
1495 incx IN POSITIVEN,
1496 y IN utl_nla_array_dbl,
1497 incy IN POSITIVEN,
1498 a IN OUT utl_nla_array_dbl,
1499 lda IN POSITIVEN,
1500 pack IN flag DEFAULT 'C');
1501
1502 PROCEDURE blas_ger(m IN POSITIVEN,
1503 n IN POSITIVEN,
1504 alpha IN scalar_float,
1505 x IN UTL_NLA_ARRAY_FLT,
1506 incx IN POSITIVEN,
1507 y IN UTL_NLA_ARRAY_FLT,
1508 incy IN POSITIVEN,
1509 a IN OUT UTL_NLA_ARRAY_FLT,
1510 lda IN POSITIVEN,
1511 pack IN flag DEFAULT 'C');
1512
1513 -- Purpose
1514 -- =======
1515 --
1516 -- BLAS_SYR performs the symmetric rank 1 operation
1517 -- A := alpha*x*x' + A,
1518 -- where alpha is a real scalar, x is an n element vector and A is an
1519 -- n by n symmetric matrix.
1520 --
1521 -- Arguments
1522 -- =========
1523 --
1524 -- UPLO - FLAG.
1525 -- On entry, UPLO specifies whether the upper or lower
1526 -- triangular part of the array A is to be referenced as
1527 -- follows:
1528 -- UPLO = 'U' or 'u' Only the upper triangular part of A
1529 -- is to be referenced.
1530 -- UPLO = 'L' or 'l' Only the lower triangular part of A
1531 -- is to be referenced.
1532 -- Unchanged on exit.
1533 -- N - INTEGER.
1534 -- On entry, N specifies the order of the matrix A.
1535 -- N must be at least zero.
1536 -- Unchanged on exit.
1537 -- ALPHA - SCALAR_FLOAT/DOUBLE .
1538 -- On entry, ALPHA specifies the scalar alpha.
1539 -- Unchanged on exit.
1540 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1541 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1542 -- Before entry, the incremented array X must contain the n
1543 -- element vector x.
1544 -- Unchanged on exit.
1545 -- INCX - INTEGER.
1546 -- On entry, INCX specifies the increment for the elements of
1547 -- X. INCX must not be zero.
1548 -- Unchanged on exit.
1549 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
1550 -- Before entry with UPLO = 'U' or 'u', the leading n by n
1551 -- upper triangular part of the array A must contain the upper
1552 -- triangular part of the symmetric matrix and the strictly
1553 -- lower triangular part of A is not referenced. On exit, the
1554 -- upper triangular part of the array A is overwritten by the
1555 -- upper triangular part of the updated matrix.
1556 -- Before entry with UPLO = 'L' or 'l', the leading n by n
1557 -- lower triangular part of the array A must contain the lower
1558 -- triangular part of the symmetric matrix and the strictly
1559 -- upper triangular part of A is not referenced. On exit, the
1560 -- lower triangular part of the array A is overwritten by the
1561 -- lower triangular part of the updated matrix.
1562 -- LDA - INTEGER.
1563 -- On entry, LDA specifies the first dimension of A as declared
1564 -- in the calling (sub) program. LDA must be at least
1565 -- max( 1, n ).
1566 -- Unchanged on exit.
1567 -- PACK - (optional) FLAG
1568 -- The packing of the matricies:
1569 -- 'C': column-major (default)
1570 -- 'R': row-major
1571
1572 PROCEDURE blas_syr(uplo IN flag,
1573 n IN POSITIVEN,
1574 alpha IN scalar_double,
1575 x IN utl_nla_array_dbl,
1576 incx IN POSITIVEN,
1577 a IN OUT utl_nla_array_dbl,
1578 lda IN POSITIVEN,
1579 pack IN flag DEFAULT 'C');
1580
1581 PROCEDURE blas_syr(uplo IN flag,
1582 n IN POSITIVEN,
1583 alpha IN scalar_float,
1584 x IN UTL_NLA_ARRAY_FLT,
1585 incx IN POSITIVEN,
1586 a IN OUT UTL_NLA_ARRAY_FLT,
1587 lda IN POSITIVEN,
1588 pack IN flag DEFAULT 'C');
1589
1590 -- Purpose
1591 -- =======
1592 --
1593 -- BLAS_SPR performs the symmetric rank 1 operation
1594 -- A := alpha*x*x' + A,
1595 -- where alpha is a real scalar, x is an n element vector and A is an
1596 -- n by n symmetric matrix, supplied in packed form.
1597 --
1598 -- Parameters
1599 -- ==========
1600 --
1601 -- UPLO - FLAG.
1602 -- On entry, UPLO specifies whether the upper or lower
1606 -- supplied in AP.
1603 -- triangular part of the matrix A is supplied in the packed
1604 -- array AP as follows:
1605 -- UPLO = 'U' or 'u' The upper triangular part of A is
1607 -- UPLO = 'L' or 'l' The lower triangular part of A is
1608 -- supplied in AP.
1609 -- Unchanged on exit.
1610 -- N - INTEGER.
1611 -- On entry, N specifies the order of the matrix A.
1612 -- N must be at least zero.
1613 -- Unchanged on exit.
1614 -- ALPHA - SCALAR_FLOAT/DOUBLE .
1615 -- On entry, ALPHA specifies the scalar alpha.
1616 -- Unchanged on exit.
1617 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1618 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1619 -- Before entry, the incremented array X must contain the n
1620 -- element vector x.
1621 -- Unchanged on exit.
1622 -- INCX - INTEGER.
1623 -- On entry, INCX specifies the increment for the elements of
1624 -- X. INCX must not be zero.
1625 -- Unchanged on exit.
1626 -- AP - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
1627 -- ( ( n*( n + 1 ) )/2 ).
1628 -- Before entry with UPLO = 'U' or 'u', the array AP must
1629 -- contain the upper triangular part of the symmetric matrix
1630 -- packed sequentially, column by column, so that AP( 1 )
1631 -- contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 )
1632 -- and a( 2, 2 ) respectively, and so on. On exit, the array
1633 -- AP is overwritten by the upper triangular part of the
1634 -- updated matrix.
1635 -- Before entry with UPLO = 'L' or 'l', the array AP must
1636 -- contain the lower triangular part of the symmetric matrix
1637 -- packed sequentially, column by column, so that AP( 1 )
1638 -- contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 )
1639 -- and a( 3, 1 ) respectively, and so on. On exit, the array
1640 -- AP is overwritten by the lower triangular part of the
1641 -- updated matrix.
1642 -- PACK - (optional) FLAG
1643 -- The packing of the matricies:
1644 -- 'C': column-major (default)
1645 -- 'R': row-major
1646
1647 PROCEDURE blas_spr(uplo IN flag,
1648 n IN POSITIVEN,
1649 alpha IN scalar_double,
1650 x IN utl_nla_array_dbl,
1651 incx IN POSITIVEN,
1652 ap IN OUT utl_nla_array_dbl,
1653 pack IN flag DEFAULT 'C');
1654
1655 PROCEDURE blas_spr(uplo IN flag,
1656 n IN POSITIVEN,
1657 alpha IN scalar_float,
1658 x IN UTL_NLA_ARRAY_FLT,
1659 incx IN POSITIVEN,
1660 ap IN OUT UTL_NLA_ARRAY_FLT,
1661 pack IN flag DEFAULT 'C');
1662
1663 -- Purpose
1664 -- =======
1665 --
1666 -- BLAS_SYR2 performs the symmetric rank 2 operation
1667 -- A := alpha*x*y' + alpha*y*x' + A,
1668 -- where alpha is a scalar, x and y are n element vectors and A is an n
1669 -- by n symmetric matrix.
1670 --
1671 -- Arguments
1672 -- =========
1673 --
1674 -- UPLO - FLAG.
1675 -- On entry, UPLO specifies whether the upper or lower
1676 -- triangular part of the array A is to be referenced as
1677 -- follows:
1678 -- UPLO = 'U' or 'u' Only the upper triangular part of A
1679 -- is to be referenced.
1680 -- UPLO = 'L' or 'l' Only the lower triangular part of A
1681 -- is to be referenced.
1682 -- Unchanged on exit.
1683 -- N - INTEGER.
1684 -- On entry, N specifies the order of the matrix A.
1685 -- N must be at least zero.
1686 -- Unchanged on exit.
1687 -- ALPHA - SCALAR_FLOAT/DOUBLE .
1688 -- On entry, ALPHA specifies the scalar alpha.
1689 -- Unchanged on exit.
1690 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1691 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1692 -- Before entry, the incremented array X must contain the n
1693 -- element vector x.
1694 -- Unchanged on exit.
1695 -- INCX - INTEGER.
1696 -- On entry, INCX specifies the increment for the elements of
1697 -- X. INCX must not be zero.
1698 -- Unchanged on exit.
1699 -- Y - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1700 -- ( 1 + ( n - 1 )*abs( INCY ) ).
1701 -- Before entry, the incremented array Y must contain the n
1702 -- element vector y.
1703 -- Unchanged on exit.
1704 -- INCY - INTEGER.
1705 -- On entry, INCY specifies the increment for the elements of
1706 -- Y. INCY must not be zero.
1707 -- Unchanged on exit.
1708 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, n ).
1709 -- Before entry with UPLO = 'U' or 'u', the leading n by n
1710 -- upper triangular part of the array A must contain the upper
1711 -- triangular part of the symmetric matrix and the strictly
1712 -- lower triangular part of A is not referenced. On exit, the
1716 -- lower triangular part of the array A must contain the lower
1713 -- upper triangular part of the array A is overwritten by the
1714 -- upper triangular part of the updated matrix.
1715 -- Before entry with UPLO = 'L' or 'l', the leading n by n
1717 -- triangular part of the symmetric matrix and the strictly
1718 -- upper triangular part of A is not referenced. On exit, the
1719 -- lower triangular part of the array A is overwritten by the
1720 -- lower triangular part of the updated matrix.
1721 -- LDA - INTEGER.
1722 -- On entry, LDA specifies the first dimension of A as declared
1723 -- in the calling (sub) program. LDA must be at least
1724 -- max( 1, n ).
1725 -- Unchanged on exit.
1726 -- PACK - (optional) FLAG
1727 -- The packing of the matricies:
1728 -- 'C': column-major (default)
1729 -- 'R': row-major
1730
1731 PROCEDURE blas_syr2(uplo IN flag,
1732 n IN POSITIVEN,
1733 alpha IN scalar_double,
1734 x IN utl_nla_array_dbl,
1735 incx IN POSITIVEN,
1736 y IN utl_nla_array_dbl,
1737 incy IN POSITIVEN,
1738 a IN OUT utl_nla_array_dbl,
1739 lda IN POSITIVEN,
1740 pack IN flag DEFAULT 'C');
1741
1742 PROCEDURE blas_syr2(uplo IN flag,
1743 n IN POSITIVEN,
1744 alpha IN scalar_float,
1745 x IN UTL_NLA_ARRAY_FLT,
1746 incx IN POSITIVEN,
1747 y IN UTL_NLA_ARRAY_FLT,
1748 incy IN POSITIVEN,
1749 a IN OUT UTL_NLA_ARRAY_FLT,
1750 lda IN POSITIVEN,
1751 pack IN flag DEFAULT 'C');
1752
1753 -- Purpose
1754 -- =======
1755 --
1756 -- BLAS_SPR2 performs the symmetric rank 2 operation
1757 -- A := alpha*x*y' + alpha*y*x' + A,
1758 -- where alpha is a scalar, x and y are n element vectors and A is an
1759 -- n by n symmetric matrix, supplied in packed form.
1760 --
1761 -- Arguments
1762 -- =========
1763 --
1764 -- UPLO - FLAG.
1765 -- On entry, UPLO specifies whether the upper or lower
1766 -- triangular part of the matrix A is supplied in the packed
1767 -- array AP as follows:
1768 -- UPLO = 'U' or 'u' The upper triangular part of A is
1769 -- supplied in AP.
1770 -- UPLO = 'L' or 'l' The lower triangular part of A is
1771 -- supplied in AP.
1772 -- Unchanged on exit.
1773 -- N - INTEGER.
1774 -- On entry, N specifies the order of the matrix A.
1775 -- N must be at least zero.
1776 -- Unchanged on exit.
1777 -- ALPHA - SCALAR_FLOAT/DOUBLE .
1778 -- On entry, ALPHA specifies the scalar alpha.
1779 -- Unchanged on exit.
1780 -- X - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1781 -- ( 1 + ( n - 1 )*abs( INCX ) ).
1782 -- Before entry, the incremented array X must contain the n
1783 -- element vector x.
1784 -- Unchanged on exit.
1785 -- INCX - INTEGER.
1786 -- On entry, INCX specifies the increment for the elements of
1787 -- X. INCX must not be zero.
1788 -- Unchanged on exit.
1789 -- Y - UTL_NLA_ARRAY_FLT/DBL of dimension at least
1790 -- ( 1 + ( n - 1 )*abs( INCY ) ).
1791 -- Before entry, the incremented array Y must contain the n
1792 -- element vector y.
1793 -- Unchanged on exit.
1794 -- INCY - INTEGER.
1795 -- On entry, INCY specifies the increment for the elements of
1796 -- Y. INCY must not be zero.
1797 -- Unchanged on exit.
1798 -- AP - UTL_NLA_ARRAY_FLT/DBL of DIMENSION at least
1799 -- ( ( n*( n + 1 ) )/2 ).
1800 -- Before entry with UPLO = 'U' or 'u', the array AP must
1801 -- contain the upper triangular part of the symmetric matrix
1802 -- packed sequentially, column by column, so that AP( 1 )
1803 -- contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 1, 2 )
1804 -- and a( 2, 2 ) respectively, and so on. On exit, the array
1805 -- AP is overwritten by the upper triangular part of the
1806 -- updated matrix.
1807 -- Before entry with UPLO = 'L' or 'l', the array AP must
1808 -- contain the lower triangular part of the symmetric matrix
1809 -- packed sequentially, column by column, so that AP( 1 )
1810 -- contains a( 1, 1 ), AP( 2 ) and AP( 3 ) contain a( 2, 1 )
1811 -- and a( 3, 1 ) respectively, and so on. On exit, the array
1812 -- AP is overwritten by the lower triangular part of the
1813 -- updated matrix.
1814 -- PACK - (optional) FLAG
1815 -- The packing of the matricies:
1816 -- 'C': column-major (default)
1817 -- 'R': row-major
1818
1819 PROCEDURE blas_spr2(uplo IN flag,
1820 n IN POSITIVEN,
1821 alpha IN scalar_double,
1822 x IN utl_nla_array_dbl,
1826 ap IN OUT utl_nla_array_dbl,
1823 incx IN POSITIVEN,
1824 y IN utl_nla_array_dbl,
1825 incy IN POSITIVEN,
1827 pack IN flag DEFAULT 'C');
1828
1829 PROCEDURE blas_spr2(uplo IN flag,
1830 n IN POSITIVEN,
1831 alpha IN scalar_float,
1832 x IN UTL_NLA_ARRAY_FLT,
1833 incx IN POSITIVEN,
1834 y IN UTL_NLA_ARRAY_FLT,
1835 incy IN POSITIVEN,
1836 ap IN OUT UTL_NLA_ARRAY_FLT,
1837 pack IN flag DEFAULT 'C');
1838
1839
1840 -- ---------------------------------------- --
1841 -- BLAS Level 3 (Matrix-Matrix Operations) --
1842 -- ---------------------------------------- --
1843
1844 -- Purpose
1845 -- =======
1846 --
1847 -- BLAS_GEMM performs one of the matrix-matrix operations
1848 -- C := alpha*op( A )*op( B ) + beta*C,
1849 -- where op( X ) is one of
1850 -- op( X ) = X or op( X ) = X',
1851 -- alpha and beta are scalars, and A, B and C are matrices, with op( A )
1852 -- an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
1853 --
1854 -- Arguments
1855 -- =========
1856 --
1857 -- TRANSA - FLAG.
1858 -- On entry, TRANSA specifies the form of op( A ) to be used in
1859 -- the matrix multiplication as follows:
1860 -- TRANSA = 'N' or 'n', op( A ) = A.
1861 -- TRANSA = 'T' or 't', op( A ) = A'.
1862 -- TRANSA = 'C' or 'c', op( A ) = A'.
1863 -- Unchanged on exit.
1864 -- TRANSB - FLAG.
1865 -- On entry, TRANSB specifies the form of op( B ) to be used in
1866 -- the matrix multiplication as follows:
1867 -- TRANSB = 'N' or 'n', op( B ) = B.
1868 -- TRANSB = 'T' or 't', op( B ) = B'.
1869 -- TRANSB = 'C' or 'c', op( B ) = B'.
1870 -- Unchanged on exit.
1871 -- M - INTEGER.
1872 -- On entry, M specifies the number of rows of the matrix
1873 -- op( A ) and of the matrix C. M must be at least zero.
1874 -- Unchanged on exit.
1875 -- N - INTEGER.
1876 -- On entry, N specifies the number of columns of the matrix
1877 -- op( B ) and the number of columns of the matrix C. N must be
1878 -- at least zero.
1879 -- Unchanged on exit.
1880 -- K - INTEGER.
1881 -- On entry, K specifies the number of columns of the matrix
1882 -- op( A ) and the number of rows of the matrix op( B ). K must
1883 -- be at least zero.
1884 -- Unchanged on exit.
1885 -- ALPHA - SCALAR_FLOAT/DOUBLE .
1886 -- On entry, ALPHA specifies the scalar alpha.
1887 -- Unchanged on exit.
1888 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, ka ), where ka is
1889 -- k when TRANSA = 'N' or 'n', and is m otherwise.
1890 -- Before entry with TRANSA = 'N' or 'n', the leading m by k
1891 -- part of the array A must contain the matrix A, otherwise
1892 -- the leading k by m part of the array A must contain the
1893 -- matrix A.
1894 -- Unchanged on exit.
1895 -- LDA - INTEGER.
1896 -- On entry, LDA specifies the first dimension of A as declared
1897 -- in the calling (sub) program. When TRANSA = 'N' or 'n' then
1898 -- LDA must be at least max( 1, m ), otherwise LDA must be at
1899 -- least max( 1, k ).
1900 -- Unchanged on exit.
1901 -- B - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDB, kb ), where kb is
1902 -- n when TRANSB = 'N' or 'n', and is k otherwise.
1903 -- Before entry with TRANSB = 'N' or 'n', the leading k by n
1904 -- part of the array B must contain the matrix B, otherwise
1905 -- the leading n by k part of the array B must contain the
1906 -- matrix B.
1907 -- Unchanged on exit.
1908 -- LDB - INTEGER.
1909 -- On entry, LDB specifies the first dimension of B as declared
1910 -- in the calling (sub) program. When TRANSB = 'N' or 'n' then
1911 -- LDB must be at least max( 1, k ), otherwise LDB must be at
1912 -- least max( 1, n ).
1913 -- Unchanged on exit.
1914 -- BETA - SCALAR_FLOAT/DOUBLE .
1915 -- On entry, BETA specifies the scalar beta. When BETA is
1916 -- supplied as zero then C need not be set on input.
1917 -- Unchanged on exit.
1918 -- C - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDC, n ).
1919 -- Before entry, the leading m by n part of the array C must
1920 -- contain the matrix C, except when beta is zero, in which
1921 -- case C need not be set on entry.
1922 -- On exit, the array C is overwritten by the m by n matrix
1923 -- ( alpha*op( A )*op( B ) + beta*C ).
1924 -- LDC - INTEGER.
1925 -- On entry, LDC specifies the first dimension of C as declared
1926 -- in the calling (sub) program. LDC must be at least
1927 -- max( 1, m ).
1928 -- PACK - (optional) FLAG
1929 -- The packing of the matricies:
1930 -- 'C': column-major (default)
1934 transb IN flag,
1931 -- 'R': row-major
1932
1933 PROCEDURE blas_gemm(transa IN flag,
1935 m IN POSITIVEN,
1936 n IN POSITIVEN,
1937 k IN POSITIVEN,
1938 alpha IN scalar_double,
1939 a IN utl_nla_array_dbl,
1940 lda IN POSITIVEN,
1941 b IN utl_nla_array_dbl,
1942 ldb IN POSITIVEN,
1943 beta IN scalar_double,
1944 c IN OUT utl_nla_array_dbl,
1945 ldc IN POSITIVEN,
1946 pack IN flag DEFAULT 'C');
1947
1948 PROCEDURE blas_gemm(transa IN flag,
1949 transb IN flag,
1950 m IN POSITIVEN,
1951 n IN POSITIVEN,
1952 k IN POSITIVEN,
1953 alpha IN scalar_float,
1954 a IN UTL_NLA_ARRAY_FLT,
1955 lda IN POSITIVEN,
1956 b IN UTL_NLA_ARRAY_FLT,
1957 ldb IN POSITIVEN,
1958 beta IN scalar_float,
1959 c IN OUT UTL_NLA_ARRAY_FLT,
1960 ldc IN POSITIVEN,
1961 pack IN flag DEFAULT 'C');
1962
1963
1964 -- Purpose
1965 -- =======
1966 --
1967 -- BLAS_SYMM performs one of the matrix-matrix operations
1968 -- C := alpha*A*B + beta*C,
1969 -- or
1970 -- C := alpha*B*A + beta*C,
1971 -- where alpha and beta are scalars, A is a symmetric matrix and B and
1972 -- C are m by n matrices.
1973 --
1974 -- Arguments
1975 -- =========
1976 --
1977 -- SIDE - FLAG.
1978 -- On entry, SIDE specifies whether the symmetric matrix A
1979 -- appears on the left or right in the operation as follows:
1980 -- SIDE = 'L' or 'l' C := alpha*A*B + beta*C,
1981 -- SIDE = 'R' or 'r' C := alpha*B*A + beta*C,
1982 -- Unchanged on exit.
1983 -- UPLO - FLAG.
1984 -- On entry, UPLO specifies whether the upper or lower
1985 -- triangular part of the symmetric matrix A is to be
1986 -- referenced as follows:
1987 -- UPLO = 'U' or 'u' Only the upper triangular part of the
1988 -- symmetric matrix is to be referenced.
1989 -- UPLO = 'L' or 'l' Only the lower triangular part of the
1990 -- symmetric matrix is to be referenced.
1991 -- Unchanged on exit.
1992 -- M - INTEGER.
1993 -- On entry, M specifies the number of rows of the matrix C.
1994 -- M must be at least zero.
1995 -- Unchanged on exit.
1996 -- N - INTEGER.
1997 -- On entry, N specifies the number of columns of the matrix C.
1998 -- N must be at least zero.
1999 -- Unchanged on exit.
2000 -- ALPHA - SCALAR_FLOAT/DOUBLE .
2001 -- On entry, ALPHA specifies the scalar alpha.
2002 -- Unchanged on exit.
2003 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, ka ), where ka is
2004 -- m when SIDE = 'L' or 'l' and is n otherwise.
2005 -- Before entry with SIDE = 'L' or 'l', the m by m part of
2006 -- the array A must contain the symmetric matrix, such that
2007 -- when UPLO = 'U' or 'u', the leading m by m upper triangular
2008 -- part of the array A must contain the upper triangular part
2009 -- of the symmetric matrix and the strictly lower triangular
2010 -- part of A is not referenced, and when UPLO = 'L' or 'l',
2011 -- the leading m by m lower triangular part of the array A
2012 -- must contain the lower triangular part of the symmetric
2013 -- matrix and the strictly upper triangular part of A is not
2014 -- referenced.
2015 -- Before entry with SIDE = 'R' or 'r', the n by n part of
2016 -- the array A must contain the symmetric matrix, such that
2017 -- when UPLO = 'U' or 'u', the leading n by n upper triangular
2018 -- part of the array A must contain the upper triangular part
2019 -- of the symmetric matrix and the strictly lower triangular
2020 -- part of A is not referenced, and when UPLO = 'L' or 'l',
2021 -- the leading n by n lower triangular part of the array A
2022 -- must contain the lower triangular part of the symmetric
2023 -- matrix and the strictly upper triangular part of A is not
2024 -- referenced.
2025 -- Unchanged on exit.
2026 -- LDA - INTEGER.
2027 -- On entry, LDA specifies the first dimension of A as declared
2028 -- in the calling (sub) program. When SIDE = 'L' or 'l' then
2029 -- LDA must be at least max( 1, m ), otherwise LDA must be at
2030 -- least max( 1, n ).
2031 -- Unchanged on exit.
2032 -- B - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDB, n ).
2033 -- Before entry, the leading m by n part of the array B must
2034 -- contain the matrix B.
2035 -- Unchanged on exit.
2036 -- LDB - INTEGER.
2040 -- Unchanged on exit.
2037 -- On entry, LDB specifies the first dimension of B as declared
2038 -- in the calling (sub) program. LDB must be at least
2039 -- max( 1, m ).
2041 -- BETA - SCALAR_FLOAT/DOUBLE .
2042 -- On entry, BETA specifies the scalar beta. When BETA is
2043 -- supplied as zero then C need not be set on input.
2044 -- Unchanged on exit.
2045 -- C - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDC, n ).
2046 -- Before entry, the leading m by n part of the array C must
2047 -- contain the matrix C, except when beta is zero, in which
2048 -- case C need not be set on entry.
2049 -- On exit, the array C is overwritten by the m by n updated
2050 -- matrix.
2051 -- LDC - INTEGER.
2052 -- On entry, LDC specifies the first dimension of C as declared
2053 -- in the calling (sub) program. LDC must be at least
2054 -- max( 1, m ).
2055 -- PACK - (optional) FLAG
2056 -- The packing of the matricies:
2057 -- 'C': column-major (default)
2058 -- 'R': row-major
2059
2060 PROCEDURE blas_symm(side IN flag,
2061 uplo IN flag,
2062 m IN POSITIVEN,
2063 n IN POSITIVEN,
2064 alpha IN scalar_double,
2065 a IN utl_nla_array_dbl,
2066 lda IN POSITIVEN,
2067 b IN utl_nla_array_dbl,
2068 ldb IN POSITIVEN,
2069 beta IN scalar_double,
2070 c IN OUT utl_nla_array_dbl,
2071 ldc IN POSITIVEN,
2072 pack IN flag DEFAULT 'C');
2073
2074 PROCEDURE blas_symm(side IN flag,
2075 uplo IN flag,
2076 m IN POSITIVEN,
2077 n IN POSITIVEN,
2078 alpha IN scalar_float,
2079 a IN UTL_NLA_ARRAY_FLT,
2080 lda IN POSITIVEN,
2081 b IN UTL_NLA_ARRAY_FLT,
2082 ldb IN POSITIVEN,
2083 beta IN scalar_float,
2084 c IN OUT UTL_NLA_ARRAY_FLT,
2085 ldc IN POSITIVEN,
2086 pack IN flag DEFAULT 'C');
2087
2088 -- Purpose
2089 -- =======
2090 --
2091 -- BLAS_TRMM performs one of the matrix-matrix operations
2092 -- B := alpha*op( A )*B, or B := alpha*B*op( A ),
2093 -- where alpha is a scalar, B is an m by n matrix, A is a unit, or
2094 -- non-unit, upper or lower triangular matrix and op( A ) is one of
2095 -- op( A ) = A or op( A ) = A'.
2096 --
2097 -- Arguments
2098 -- =========
2099 --
2100 -- SIDE - FLAG.
2101 -- On entry, SIDE specifies whether op( A ) multiplies B from
2102 -- the left or right as follows:
2103 -- SIDE = 'L' or 'l' B := alpha*op( A )*B.
2104 -- SIDE = 'R' or 'r' B := alpha*B*op( A ).
2105 -- Unchanged on exit.
2106 -- UPLO - FLAG.
2107 -- On entry, UPLO specifies whether the matrix A is an upper or
2108 -- lower triangular matrix as follows:
2109 -- UPLO = 'U' or 'u' A is an upper triangular matrix.
2110 -- UPLO = 'L' or 'l' A is a lower triangular matrix.
2111 -- Unchanged on exit.
2112 -- TRANSA - FLAG.
2113 -- On entry, TRANSA specifies the form of op( A ) to be used in
2114 -- the matrix multiplication as follows:
2115 -- TRANSA = 'N' or 'n' op( A ) = A.
2116 -- TRANSA = 'T' or 't' op( A ) = A'.
2117 -- TRANSA = 'C' or 'c' op( A ) = A'.
2118 -- Unchanged on exit.
2119 -- DIAG - FLAG.
2120 -- On entry, DIAG specifies whether or not A is unit triangular
2121 -- as follows:
2122 -- DIAG = 'U' or 'u' A is assumed to be unit triangular.
2123 -- DIAG = 'N' or 'n' A is not assumed to be unit
2124 -- triangular.
2125 -- Unchanged on exit.
2126 -- M - INTEGER.
2127 -- On entry, M specifies the number of rows of B. M must be at
2128 -- least zero.
2129 -- Unchanged on exit.
2130 -- N - INTEGER.
2131 -- On entry, N specifies the number of columns of B. N must be
2132 -- at least zero.
2133 -- Unchanged on exit.
2134 -- ALPHA - SCALAR_FLOAT/DOUBLE .
2135 -- On entry, ALPHA specifies the scalar alpha. When alpha is
2136 -- zero then A is not referenced and B need not be set before
2137 -- entry.
2138 -- Unchanged on exit.
2139 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, k ), where k is m
2140 -- when SIDE = 'L' or 'l' and is n when SIDE = 'R' or 'r'.
2141 -- Before entry with UPLO = 'U' or 'u', the leading k by k
2142 -- upper triangular part of the array A must contain the upper
2143 -- triangular matrix and the strictly lower triangular part of
2144 -- A is not referenced.
2145 -- Before entry with UPLO = 'L' or 'l', the leading k by k
2146 -- lower triangular part of the array A must contain the lower
2150 -- A are not referenced either, but are assumed to be unity.
2147 -- triangular matrix and the strictly upper triangular part of
2148 -- A is not referenced.
2149 -- Note that when DIAG = 'U' or 'u', the diagonal elements of
2151 -- Unchanged on exit.
2152 -- LDA - INTEGER.
2153 -- On entry, LDA specifies the first dimension of A as declared
2154 -- in the calling (sub) program. When SIDE = 'L' or 'l' then
2155 -- LDA must be at least max( 1, m ), when SIDE = 'R' or 'r'
2156 -- then LDA must be at least max( 1, n ).
2157 -- Unchanged on exit.
2158 -- B - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDB, n ).
2159 -- Before entry, the leading m by n part of the array B must
2160 -- contain the matrix B, and on exit is overwritten by the
2161 -- transformed matrix.
2162 -- LDB - INTEGER.
2163 -- On entry, LDB specifies the first dimension of B as declared
2164 -- in the calling (sub) program. LDB must be at least
2165 -- max( 1, m ).
2166 -- PACK - (optional) FLAG
2167 -- The packing of the matricies:
2168 -- 'C': column-major (default)
2169 -- 'R': row-major
2170
2171 PROCEDURE blas_trmm(side IN flag,
2172 uplo IN flag,
2173 transa IN flag,
2174 diag IN flag,
2175 m IN POSITIVEN,
2176 n IN POSITIVEN,
2177 alpha IN scalar_double,
2178 a IN utl_nla_array_dbl,
2179 lda IN POSITIVEN,
2180 b IN OUT utl_nla_array_dbl,
2181 ldb IN POSITIVEN,
2182 pack IN flag DEFAULT 'C');
2183
2184 PROCEDURE blas_trmm(side IN flag,
2185 uplo IN flag,
2186 transa IN flag,
2187 diag IN flag,
2188 m IN POSITIVEN,
2189 n IN POSITIVEN,
2190 alpha IN scalar_float,
2191 a IN UTL_NLA_ARRAY_FLT,
2192 lda IN POSITIVEN,
2193 b IN OUT UTL_NLA_ARRAY_FLT,
2194 ldb IN POSITIVEN,
2195 pack IN flag DEFAULT 'C');
2196
2197 -- Purpose
2198 -- =======
2199 --
2200 -- BLAS_TRSM solves one of the matrix equations
2201 -- op( A )*X = alpha*B, or X*op( A ) = alpha*B,
2202 -- where alpha is a scalar, X and B are m by n matrices, A is a unit, or
2203 -- non-unit, upper or lower triangular matrix and op( A ) is one of
2204 -- op( A ) = A or op( A ) = A'.
2205 -- The matrix X is overwritten on B.
2206 --
2207 -- Parameters
2208 -- ==========
2209 --
2210 -- SIDE - FLAG.
2211 -- On entry, SIDE specifies whether op( A ) appears on the left
2212 -- or right of X as follows:
2213 -- SIDE = 'L' or 'l' op( A )*X = alpha*B.
2214 -- SIDE = 'R' or 'r' X*op( A ) = alpha*B.
2215 -- Unchanged on exit.
2216 -- UPLO - FLAG.
2217 -- On entry, UPLO specifies whether the matrix A is an upper or
2218 -- lower triangular matrix as follows:
2219 -- UPLO = 'U' or 'u' A is an upper triangular matrix.
2220 -- UPLO = 'L' or 'l' A is a lower triangular matrix.
2221 -- Unchanged on exit.
2222 -- TRANSA - FLAG.
2223 -- On entry, TRANSA specifies the form of op( A ) to be used in
2224 -- the matrix multiplication as follows:
2225 -- TRANSA = 'N' or 'n' op( A ) = A.
2226 -- TRANSA = 'T' or 't' op( A ) = A'.
2227 -- TRANSA = 'C' or 'c' op( A ) = A'.
2228 -- Unchanged on exit.
2229 -- DIAG - FLAG.
2230 -- On entry, DIAG specifies whether or not A is unit triangular
2231 -- as follows:
2232 -- DIAG = 'U' or 'u' A is assumed to be unit triangular.
2233 -- DIAG = 'N' or 'n' A is not assumed to be unit
2234 -- triangular.
2235 -- Unchanged on exit.
2236 -- M - INTEGER.
2237 -- On entry, M specifies the number of rows of B. M must be at
2238 -- least zero.
2239 -- Unchanged on exit.
2240 -- N - INTEGER.
2241 -- On entry, N specifies the number of columns of B. N must be
2242 -- at least zero.
2243 -- Unchanged on exit.
2244 -- ALPHA - SCALAR_FLOAT/DOUBLE .
2245 -- On entry, ALPHA specifies the scalar alpha. When alpha is
2246 -- zero then A is not referenced and B need not be set before
2247 -- entry.
2248 -- Unchanged on exit.
2249 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, k ), where k is m
2250 -- when SIDE = 'L' or 'l' and is n when SIDE = 'R' or 'r'.
2251 -- Before entry with UPLO = 'U' or 'u', the leading k by k
2252 -- upper triangular part of the array A must contain the upper
2253 -- triangular matrix and the strictly lower triangular part of
2254 -- A is not referenced.
2255 -- Before entry with UPLO = 'L' or 'l', the leading k by k
2256 -- lower triangular part of the array A must contain the lower
2260 -- A are not referenced either, but are assumed to be unity.
2257 -- triangular matrix and the strictly upper triangular part of
2258 -- A is not referenced.
2259 -- Note that when DIAG = 'U' or 'u', the diagonal elements of
2261 -- Unchanged on exit.
2262 -- LDA - INTEGER.
2263 -- On entry, LDA specifies the first dimension of A as declared
2264 -- in the calling (sub) program. When SIDE = 'L' or 'l' then
2265 -- LDA must be at least max( 1, m ), when SIDE = 'R' or 'r'
2266 -- then LDA must be at least max( 1, n ).
2267 -- Unchanged on exit.
2268 -- B - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDB, n ).
2269 -- Before entry, the leading m by n part of the array B must
2270 -- contain the right-hand side matrix B, and on exit is
2271 -- overwritten by the solution matrix X.
2272 -- LDB - INTEGER.
2273 -- On entry, LDB specifies the first dimension of B as declared
2274 -- in the calling (sub) program. LDB must be at least
2275 -- max( 1, m ).
2276 -- Unchanged on exit.
2277 -- PACK - (optional) FLAG
2278 -- The packing of the matricies:
2279 -- 'C': column-major (default)
2280 -- 'R': row-major
2281
2282 PROCEDURE blas_trsm(side IN flag,
2283 uplo IN flag,
2284 transa IN flag,
2285 diag IN flag,
2286 m IN POSITIVEN,
2287 n IN POSITIVEN,
2288 alpha IN scalar_double,
2289 a IN utl_nla_array_dbl,
2290 lda IN POSITIVEN,
2291 b IN OUT utl_nla_array_dbl,
2292 ldb IN POSITIVEN,
2293 pack IN flag DEFAULT 'C');
2294
2295 PROCEDURE blas_trsm(side IN flag,
2296 uplo IN flag,
2297 transa IN flag,
2298 diag IN flag,
2299 m IN POSITIVEN,
2300 n IN POSITIVEN,
2301 alpha IN scalar_float,
2302 a IN UTL_NLA_ARRAY_FLT,
2303 lda IN POSITIVEN,
2304 b IN OUT UTL_NLA_ARRAY_FLT,
2305 ldb IN POSITIVEN,
2306 pack IN flag DEFAULT 'C');
2307
2308 -- Purpose
2309 -- =======
2310 --
2311 -- BLAS_SYRK performs one of the symmetric rank k operations
2312 -- C := alpha*A*A' + beta*C,
2313 -- or
2314 -- C := alpha*A'*A + beta*C,
2315 -- where alpha and beta are scalars, C is an n by n symmetric matrix
2316 -- and A is an n by k matrix in the first case and a k by n matrix
2317 -- in the second case.
2318 --
2319 -- Arguments
2320 -- =========
2321 -- UPLO - FLAG.
2322 -- On entry, UPLO specifies whether the upper or lower
2323 -- triangular part of the array C is to be referenced as
2324 -- follows:
2325 -- UPLO = 'U' or 'u' Only the upper triangular part of C
2326 -- is to be referenced.
2327 -- UPLO = 'L' or 'l' Only the lower triangular part of C
2328 -- is to be referenced.
2329 -- Unchanged on exit.
2330 -- TRANS - FLAG.
2331 -- On entry, TRANS specifies the operation to be performed as
2332 -- follows:
2333 -- TRANS = 'N' or 'n' C := alpha*A*A' + beta*C.
2334 -- TRANS = 'T' or 't' C := alpha*A'*A + beta*C.
2335 -- TRANS = 'C' or 'c' C := alpha*A'*A + beta*C.
2336 -- Unchanged on exit.
2337 -- N - INTEGER.
2338 -- On entry, N specifies the order of the matrix C. N must be
2339 -- at least zero.
2340 -- Unchanged on exit.
2341 -- K - INTEGER.
2342 -- On entry with TRANS = 'N' or 'n', K specifies the number
2343 -- of columns of the matrix A, and on entry with
2344 -- TRANS = 'T' or 't' or 'C' or 'c', K specifies the number
2345 -- of rows of the matrix A. K must be at least zero.
2346 -- Unchanged on exit.
2347 -- ALPHA - SCALAR_FLOAT/DOUBLE .
2348 -- On entry, ALPHA specifies the scalar alpha.
2349 -- Unchanged on exit.
2350 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, ka ), where ka is
2351 -- k when TRANS = 'N' or 'n', and is n otherwise.
2352 -- Before entry with TRANS = 'N' or 'n', the leading n by k
2353 -- part of the array A must contain the matrix A, otherwise
2354 -- the leading k by n part of the array A must contain the
2355 -- matrix A.
2356 -- Unchanged on exit.
2357 -- LDA - INTEGER.
2358 -- On entry, LDA specifies the first dimension of A as declared
2359 -- in the calling (sub) program. When TRANS = 'N' or 'n'
2360 -- then LDA must be at least max( 1, n ), otherwise LDA must
2361 -- be at least max( 1, k ).
2362 -- Unchanged on exit.
2363 -- BETA - SCALAR_FLOAT/DOUBLE .
2364 -- On entry, BETA specifies the scalar beta.
2365 -- Unchanged on exit.
2369 -- triangular part of the symmetric matrix and the strictly
2366 -- C - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDC, n ).
2367 -- Before entry with UPLO = 'U' or 'u', the leading n by n
2368 -- upper triangular part of the array C must contain the upper
2370 -- lower triangular part of C is not referenced. On exit, the
2371 -- upper triangular part of the array C is overwritten by the
2372 -- upper triangular part of the updated matrix.
2373 -- Before entry with UPLO = 'L' or 'l', the leading n by n
2374 -- lower triangular part of the array C must contain the lower
2375 -- triangular part of the symmetric matrix and the strictly
2376 -- upper triangular part of C is not referenced. On exit, the
2377 -- lower triangular part of the array C is overwritten by the
2378 -- lower triangular part of the updated matrix.
2379 -- LDC - INTEGER.
2380 -- On entry, LDC specifies the first dimension of C as declared
2381 -- in the calling (sub) program. LDC must be at least
2382 -- max( 1, n ).
2383 -- Unchanged on exit.
2384 -- PACK - (optional) FLAG
2385 -- The packing of the matricies:
2386 -- 'C': column-major (default)
2387 -- 'R': row-major
2388
2389 PROCEDURE blas_syrk(uplo IN flag,
2390 trans IN flag,
2391 n IN POSITIVEN,
2392 k IN POSITIVEN,
2393 alpha IN scalar_double,
2394 a IN utl_nla_array_dbl,
2395 lda IN POSITIVEN,
2396 beta IN scalar_double,
2397 c IN OUT utl_nla_array_dbl,
2398 ldc IN POSITIVEN,
2399 pack IN flag DEFAULT 'C');
2400
2401 PROCEDURE blas_syrk(uplo IN flag,
2402 trans IN flag,
2403 n IN POSITIVEN,
2404 k IN POSITIVEN,
2405 alpha IN scalar_float,
2406 a IN UTL_NLA_ARRAY_FLT,
2407 lda IN POSITIVEN,
2408 beta IN scalar_float,
2409 c IN OUT UTL_NLA_ARRAY_FLT,
2410 ldc IN POSITIVEN,
2411 pack IN flag DEFAULT 'C');
2412
2413 -- Purpose
2414 -- =======
2415 --
2416 -- BLAS_SYR2K performs one of the symmetric rank 2k operations
2417 -- C := alpha*A*B' + alpha*B*A' + beta*C,
2418 -- or
2419 -- C := alpha*A'*B + alpha*B'*A + beta*C,
2420 -- where alpha and beta are scalars, C is an n by n symmetric matrix
2421 -- and A and B are n by k matrices in the first case and k by n
2422 -- matrices in the second case.
2423 --
2424 -- Arguments
2425 -- =========
2426 -- UPLO - FLAG.
2427 -- On entry, UPLO specifies whether the upper or lower
2428 -- triangular part of the array C is to be referenced as
2429 -- follows:
2430 -- UPLO = 'U' or 'u' Only the upper triangular part of C
2431 -- is to be referenced.
2432 -- UPLO = 'L' or 'l' Only the lower triangular part of C
2433 -- is to be referenced.
2434 -- Unchanged on exit.
2435 -- TRANS - FLAG.
2436 -- On entry, TRANS specifies the operation to be performed as
2437 -- follows:
2438 -- TRANS = 'N' or 'n' C := alpha*A*B' + alpha*B*A' +
2439 -- beta*C.
2440 -- TRANS = 'T' or 't' C := alpha*A'*B + alpha*B'*A +
2441 -- beta*C.
2442 -- TRANS = 'C' or 'c' C := alpha*A'*B + alpha*B'*A +
2443 -- beta*C.
2444 -- Unchanged on exit.
2445 -- N - INTEGER.
2446 -- On entry, N specifies the order of the matrix C. N must be
2447 -- at least zero.
2448 -- Unchanged on exit.
2449 -- K - INTEGER.
2450 -- On entry with TRANS = 'N' or 'n', K specifies the number
2451 -- of columns of the matrices A and B, and on entry with
2452 -- TRANS = 'T' or 't' or 'C' or 'c', K specifies the number
2453 -- of rows of the matrices A and B. K must be at least zero.
2454 -- Unchanged on exit.
2455 -- ALPHA - SCALAR_FLOAT/DOUBLE .
2456 -- On entry, ALPHA specifies the scalar alpha.
2457 -- Unchanged on exit.
2458 -- A - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDA, ka ), where ka is
2459 -- k when TRANS = 'N' or 'n', and is n otherwise.
2460 -- Before entry with TRANS = 'N' or 'n', the leading n by k
2461 -- part of the array A must contain the matrix A, otherwise
2462 -- the leading k by n part of the array A must contain the
2463 -- matrix A.
2464 -- Unchanged on exit.
2465 -- LDA - INTEGER.
2466 -- On entry, LDA specifies the first dimension of A as declared
2467 -- in the calling (sub) program. When TRANS = 'N' or 'n'
2468 -- then LDA must be at least max( 1, n ), otherwise LDA must
2469 -- be at least max( 1, k ).
2470 -- Unchanged on exit.
2474 -- part of the array B must contain the matrix B, otherwise
2471 -- B - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDB, kb ), where kb is
2472 -- k when TRANS = 'N' or 'n', and is n otherwise.
2473 -- Before entry with TRANS = 'N' or 'n', the leading n by k
2475 -- the leading k by n part of the array B must contain the
2476 -- matrix B.
2477 -- Unchanged on exit.
2478 -- LDB - INTEGER.
2479 -- On entry, LDB specifies the first dimension of B as declared
2480 -- in the calling (sub) program. When TRANS = 'N' or 'n'
2481 -- then LDB must be at least max( 1, n ), otherwise LDB must
2482 -- be at least max( 1, k ).
2483 -- Unchanged on exit.
2484 -- BETA - SCALAR_FLOAT/DOUBLE .
2485 -- On entry, BETA specifies the scalar beta.
2486 -- Unchanged on exit.
2487 -- C - UTL_NLA_ARRAY_FLT/DBL of DIMENSION ( LDC, n ).
2488 -- Before entry with UPLO = 'U' or 'u', the leading n by n
2489 -- upper triangular part of the array C must contain the upper
2490 -- triangular part of the symmetric matrix and the strictly
2491 -- lower triangular part of C is not referenced. On exit, the
2492 -- upper triangular part of the array C is overwritten by the
2493 -- upper triangular part of the updated matrix.
2494 -- Before entry with UPLO = 'L' or 'l', the leading n by n
2495 -- lower triangular part of the array C must contain the lower
2496 -- triangular part of the symmetric matrix and the strictly
2497 -- upper triangular part of C is not referenced. On exit, the
2498 -- lower triangular part of the array C is overwritten by the
2499 -- lower triangular part of the updated matrix.
2500 -- LDC - INTEGER.
2501 -- On entry, LDC specifies the first dimension of C as declared
2502 -- in the calling (sub) program. LDC must be at least
2503 -- max( 1, n ).
2504 -- Unchanged on exit.
2505 -- PACK - (optional) FLAG
2506 -- The packing of the matricies:
2507 -- 'C': column-major (default)
2508 -- 'R': row-major
2509
2510 PROCEDURE blas_syr2k(uplo IN flag,
2511 trans IN flag,
2512 n IN POSITIVEN,
2513 k IN POSITIVEN,
2514 alpha IN scalar_double,
2515 a IN utl_nla_array_dbl,
2516 lda IN POSITIVEN,
2517 b IN utl_nla_array_dbl,
2518 ldb IN POSITIVEN,
2519 beta IN scalar_double,
2520 c IN OUT utl_nla_array_dbl,
2521 ldc IN POSITIVEN,
2522 pack IN flag DEFAULT 'C');
2523
2524 PROCEDURE blas_syr2k(uplo IN flag,
2525 trans IN flag,
2526 n IN POSITIVEN,
2527 k IN POSITIVEN,
2528 alpha IN scalar_float,
2529 a IN UTL_NLA_ARRAY_FLT,
2530 lda IN POSITIVEN,
2531 b IN UTL_NLA_ARRAY_FLT,
2532 ldb IN POSITIVEN,
2533 beta IN scalar_float,
2534 c IN OUT UTL_NLA_ARRAY_FLT,
2535 ldc IN POSITIVEN,
2536 pack IN flag DEFAULT 'C');
2537
2538
2539 -- ------------------------------------------ --
2540 -- LAPACK Driver Routines: Linear Equations --
2541 -- ------------------------------------------ --
2542
2543 --
2544 -- Purpose
2545 -- =======
2546 --
2547 -- LAPACK_GESV computes the solution to a real system of linear equations
2548 -- A * X = B,
2549 -- where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
2550 --
2551 -- The LU decomposition with partial pivoting and row interchanges is
2552 -- used to factor A as
2553 -- A = P * L * U,
2554 -- where P is a permutation matrix, L is unit lower triangular, and U is
2555 -- upper triangular. The factored form of A is then used to solve the
2556 -- system of equations A * X = B.
2557 --
2558 -- Arguments
2559 -- =========
2560 --
2561 -- N (input) INTEGER
2562 -- The number of linear equations, i.e., the order of the
2563 -- matrix A. N >= 0.
2564 --
2565 -- NRHS (input) INTEGER
2566 -- The number of right hand sides, i.e., the number of columns
2567 -- of the matrix B. NRHS >= 0.
2568 --
2569 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA,N)
2570 -- On entry, the N-by-N coefficient matrix A.
2571 -- On exit, the factors L and U from the factorization
2572 -- A = P*L*U; the unit diagonal elements of L are not stored.
2573 --
2574 -- LDA (input) INTEGER
2575 -- The leading dimension of the array A. LDA >= max(1,N).
2576 --
2577 -- IPIV (output) INTEGER array, dimension (N)
2578 -- The pivot indices that define the permutation matrix P;
2579 -- row i of the matrix was interchanged with row IPIV(i).
2580 --
2581 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
2582 -- On entry, the N-by-NRHS matrix of right hand side matrix B.
2586 -- The leading dimension of the array B. LDB >= max(1,N).
2583 -- On exit, if INFO = 0, the N-by-NRHS solution matrix X.
2584 --
2585 -- LDB (input) INTEGER
2587 --
2588 -- INFO (output) INTEGER
2589 -- = 0: successful exit
2590 -- < 0: if INFO = -i, the i-th argument had an illegal value
2591 -- > 0: if INFO = i, U(i,i) is exactly zero. The factorization
2592 -- has been completed, but the factor U is exactly
2593 -- singular, so the solution could not be computed.
2594 -- PACK - (optional) FLAG
2595 -- The packing of the matricies:
2596 -- 'C': column-major (default)
2597 -- 'R': row-major
2598
2599 PROCEDURE lapack_gesv(n IN POSITIVEN,
2600 nrhs IN POSITIVEN,
2601 a IN OUT utl_nla_array_dbl,
2602 lda IN POSITIVEN,
2603 ipiv IN OUT UTL_NLA_ARRAY_INT,
2604 b IN OUT utl_nla_array_dbl,
2605 ldb IN POSITIVEN,
2606 info OUT integer,
2607 pack IN flag DEFAULT 'C');
2608
2609 PROCEDURE lapack_gesv(n IN POSITIVEN,
2610 nrhs IN POSITIVEN,
2611 a IN OUT UTL_NLA_ARRAY_FLT,
2612 lda IN POSITIVEN,
2613 ipiv IN OUT UTL_NLA_ARRAY_INT,
2614 b IN OUT UTL_NLA_ARRAY_FLT,
2615 ldb IN POSITIVEN,
2616 info OUT integer,
2617 pack IN flag DEFAULT 'C');
2618
2619 --
2620 -- Purpose
2621 -- =======
2622 --
2623 -- LAPACK_GBSV computes the solution to a real system of linear equations
2624 -- A * X = B, where A is a band matrix of order N with KL subdiagonals
2625 -- and KU superdiagonals, and X and B are N-by-NRHS matrices.
2626 --
2627 -- The LU decomposition with partial pivoting and row interchanges is
2628 -- used to factor A as A = L * U, where L is a product of permutation
2629 -- and unit lower triangular matrices with KL subdiagonals, and U is
2630 -- upper triangular with KL+KU superdiagonals. The factored form of A
2631 -- is then used to solve the system of equations A * X = B.
2632 --
2633 -- Arguments
2634 -- =========
2635 --
2636 -- N (input) INTEGER
2637 -- The number of linear equations, i.e., the order of the
2638 -- matrix A. N >= 0.
2639 --
2640 -- KL (input) INTEGER
2641 -- The number of subdiagonals within the band of A. KL >= 0.
2642 --
2643 -- KU (input) INTEGER
2644 -- The number of superdiagonals within the band of A. KU >= 0.
2645 --
2646 -- NRHS (input) INTEGER
2647 -- The number of right hand sides, i.e., the number of columns
2648 -- of the matrix B. NRHS >= 0.
2649 --
2650 -- AB (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDAB,N)
2651 -- On entry, the matrix A in band storage, in rows KL+1 to
2652 -- 2*KL+KU+1; rows 1 to KL of the array need not be set.
2653 -- The j-th column of A is stored in the j-th column of the
2654 -- array AB as follows:
2655 -- AB(KL+KU+1+i-j,j) = A(i,j) for max(1,j-KU)<=i<=min(N,j+KL)
2656 -- On exit, details of the factorization: U is stored as an
2657 -- upper triangular band matrix with KL+KU superdiagonals in
2658 -- rows 1 to KL+KU+1, and the multipliers used during the
2659 -- factorization are stored in rows KL+KU+2 to 2*KL+KU+1.
2660 -- See below for further details.
2661 --
2662 -- LDAB (input) INTEGER
2663 -- The leading dimension of the array AB. LDAB >= 2*KL+KU+1.
2664 --
2665 -- IPIV (output) INTEGER array, dimension (N)
2666 -- The pivot indices that define the permutation matrix P;
2667 -- row i of the matrix was interchanged with row IPIV(i).
2668 --
2669 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
2670 -- On entry, the N-by-NRHS right hand side matrix B.
2671 -- On exit, if INFO = 0, the N-by-NRHS solution matrix X.
2672 --
2673 -- LDB (input) INTEGER
2674 -- The leading dimension of the array B. LDB >= max(1,N).
2675 --
2676 -- INFO (output) INTEGER
2677 -- = 0: successful exit
2678 -- < 0: if INFO = -i, the i-th argument had an illegal value
2679 -- > 0: if INFO = i, U(i,i) is exactly zero. The factorization
2680 -- has been completed, but the factor U is exactly
2681 -- singular, and the solution has not been computed.
2682 --
2683 -- PACK - (optional) FLAG
2684 -- The packing of the matricies:
2685 -- 'C': column-major (default)
2686 -- 'R': row-major
2687
2688 PROCEDURE lapack_gbsv (n IN POSITIVEN,
2689 kl IN NATURALN,
2690 ku IN NATURALN,
2691 nrhs IN POSITIVEN,
2692 ab IN OUT utl_nla_array_dbl,
2693 ldab IN POSITIVEN,
2694 ipiv IN OUT UTL_NLA_ARRAY_INT,
2695 b IN OUT utl_nla_array_dbl,
2696 ldb IN POSITIVEN,
2697 info OUT integer,
2701 kl IN NATURALN,
2698 pack IN flag DEFAULT 'C');
2699
2700 PROCEDURE lapack_gbsv (n IN POSITIVEN,
2702 ku IN NATURALN,
2703 nrhs IN POSITIVEN,
2704 ab IN OUT UTL_NLA_ARRAY_FLT,
2705 ldab IN POSITIVEN,
2706 ipiv IN OUT UTL_NLA_ARRAY_INT,
2707 b IN OUT UTL_NLA_ARRAY_FLT,
2708 ldb IN POSITIVEN,
2709 info OUT integer,
2710 pack IN flag DEFAULT 'C');
2711
2712 --
2713 -- Purpose
2714 -- =======
2715 --
2716 -- LAPACK_GTSV solves the equation
2717 --
2718 -- A*X = B,
2719 --
2720 -- where A is an n by n tridiagonal matrix, by Gaussian elimination with
2721 -- partial pivoting.
2722 --
2723 -- Note that the equation A'*X = B may be solved by interchanging the
2724 -- order of the arguments DU and DL.
2725 --
2726 -- Arguments
2727 -- =========
2728 --
2729 -- N (input) INTEGER
2730 -- The order of the matrix A. N >= 0.
2731 --
2732 -- NRHS (input) INTEGER
2733 -- The number of right hand sides, i.e., the number of columns
2734 -- of the matrix B. NRHS >= 0.
2735 --
2736 -- DL (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N-1)
2737 -- On entry, DL must contain the (n-1) sub-diagonal elements of
2738 -- A.
2739 --
2740 -- On exit, DL is overwritten by the (n-2) elements of the
2741 -- second super-diagonal of the upper triangular matrix U from
2742 -- the LU factorization of A, in DL(1), ..., DL(n-2).
2743 --
2744 -- D (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
2745 -- On entry, D must contain the diagonal elements of A.
2746 --
2747 -- On exit, D is overwritten by the n diagonal elements of U.
2748 --
2749 -- DU (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N-1)
2750 -- On entry, DU must contain the (n-1) super-diagonal elements
2751 -- of A.
2752 --
2753 -- On exit, DU is overwritten by the (n-1) elements of the first
2754 -- super-diagonal of U.
2755 --
2756 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
2757 -- On entry, the N by NRHS matrix of right hand side matrix B.
2758 -- On exit, if INFO = 0, the N by NRHS solution matrix X.
2759 --
2760 -- LDB (input) INTEGER
2761 -- The leading dimension of the array B. LDB >= max(1,N).
2762 --
2763 -- INFO (output) INTEGER
2764 -- = 0: successful exit
2765 -- < 0: if INFO = -i, the i-th argument had an illegal value
2766 -- > 0: if INFO = i, U(i,i) is exactly zero, and the solution
2767 -- has not been computed. The factorization has not been
2768 -- completed unless i = N.
2769 -- PACK - (optional) FLAG
2770 -- The packing of the matricies:
2771 -- 'C': column-major (default)
2772 -- 'R': row-major
2773
2774 PROCEDURE lapack_gtsv (n IN POSITIVEN,
2775 nrhs IN POSITIVEN,
2776 dl IN OUT utl_nla_array_dbl,
2777 d IN OUT utl_nla_array_dbl,
2778 du IN OUT utl_nla_array_dbl,
2779 b IN OUT utl_nla_array_dbl,
2780 ldb IN POSITIVEN,
2781 info OUT integer,
2782 pack IN flag DEFAULT 'C');
2783
2784 PROCEDURE lapack_gtsv (n IN POSITIVEN,
2785 nrhs IN POSITIVEN,
2786 dl IN OUT UTL_NLA_ARRAY_FLT,
2787 d IN OUT UTL_NLA_ARRAY_FLT,
2788 du IN OUT UTL_NLA_ARRAY_FLT,
2789 b IN OUT UTL_NLA_ARRAY_FLT,
2790 ldb IN POSITIVEN,
2791 info OUT integer,
2792 pack IN flag DEFAULT 'C');
2793
2794 --
2795 -- Purpose
2796 -- =======
2797 --
2798 -- LAPACK_POSV computes the solution to a real system of linear equations
2799 -- A * X = B,
2800 -- where A is an N-by-N symmetric positive definite matrix and X and B
2801 -- are N-by-NRHS matrices.
2802 --
2803 -- The Cholesky decomposition is used to factor A as
2804 -- A = U**T* U, if UPLO = 'U', or
2805 -- A = L * L**T, if UPLO = 'L',
2806 -- where U is an upper triangular matrix and L is a lower triangular
2807 -- matrix. The factored form of A is then used to solve the system of
2808 -- equations A * X = B.
2809 --
2810 -- Arguments
2811 -- =========
2812 --
2813 -- UPLO (input) FLAG
2814 -- = 'U': Upper triangle of A is stored;
2815 -- = 'L': Lower triangle of A is stored.
2816 --
2817 -- N (input) INTEGER
2818 -- The number of linear equations, i.e., the order of the
2819 -- matrix A. N >= 0.
2820 --
2821 -- NRHS (input) INTEGER
2822 -- The number of right hand sides, i.e., the number of columns
2823 -- of the matrix B. NRHS >= 0.
2824 --
2828 -- triangular part of the matrix A, and the strictly lower
2825 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA,N)
2826 -- On entry, the symmetric matrix A. If UPLO = 'U', the leading
2827 -- N-by-N upper triangular part of A contains the upper
2829 -- triangular part of A is not referenced. If UPLO = 'L', the
2830 -- leading N-by-N lower triangular part of A contains the lower
2831 -- triangular part of the matrix A, and the strictly upper
2832 -- triangular part of A is not referenced.
2833 --
2834 -- On exit, if INFO = 0, the factor U or L from the Cholesky
2835 -- factorization A = U**T*U or A = L*L**T.
2836 --
2837 -- LDA (input) INTEGER
2838 -- The leading dimension of the array A. LDA >= max(1,N).
2839 --
2840 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
2841 -- On entry, the N-by-NRHS right hand side matrix B.
2842 -- On exit, if INFO = 0, the N-by-NRHS solution matrix X.
2843 --
2844 -- LDB (input) INTEGER
2845 -- The leading dimension of the array B. LDB >= max(1,N).
2846 --
2847 -- INFO (output) INTEGER
2848 -- = 0: successful exit
2849 -- < 0: if INFO = -i, the i-th argument had an illegal value
2850 -- > 0: if INFO = i, the leading minor of order i of A is not
2851 -- positive definite, so the factorization could not be
2852 -- completed, and the solution has not been computed.
2853 -- PACK - (optional) FLAG
2854 -- The packing of the matricies:
2855 -- 'C': column-major (default)
2856 -- 'R': row-major
2857
2858 PROCEDURE lapack_posv (uplo IN flag,
2859 n IN POSITIVEN,
2860 nrhs IN POSITIVEN,
2861 a IN OUT utl_nla_array_dbl,
2862 lda IN POSITIVEN,
2863 b IN OUT utl_nla_array_dbl,
2864 ldb IN POSITIVEN,
2865 info OUT integer,
2866 pack IN flag DEFAULT 'C');
2867
2868 PROCEDURE lapack_posv (uplo IN flag,
2869 n IN POSITIVEN,
2870 nrhs IN POSITIVEN,
2871 a IN OUT UTL_NLA_ARRAY_FLT,
2872 lda IN POSITIVEN,
2873 b IN OUT UTL_NLA_ARRAY_FLT,
2874 ldb IN POSITIVEN,
2875 info OUT integer,
2876 pack IN flag DEFAULT 'C');
2877
2878 --
2879 -- Purpose
2880 -- =======
2881 --
2882 -- LAPACK_PPSV computes the solution to a real system of linear equations
2883 -- A * X = B,
2884 -- where A is an N-by-N symmetric positive definite matrix stored in
2885 -- packed format and X and B are N-by-NRHS matrices.
2886 --
2887 -- The Cholesky decomposition is used to factor A as
2888 -- A = U**T* U, if UPLO = 'U', or
2889 -- A = L * L**T, if UPLO = 'L',
2890 -- where U is an upper triangular matrix and L is a lower triangular
2891 -- matrix. The factored form of A is then used to solve the system of
2892 -- equations A * X = B.
2893 --
2894 -- Arguments
2895 -- =========
2896 --
2897 -- UPLO (input) FLAG
2898 -- = 'U': Upper triangle of A is stored;
2899 -- = 'L': Lower triangle of A is stored.
2900 --
2901 -- N (input) INTEGER
2902 -- The number of linear equations, i.e., the order of the
2903 -- matrix A. N >= 0.
2904 --
2905 -- NRHS (input) INTEGER
2906 -- The number of right hand sides, i.e., the number of columns
2907 -- of the matrix B. NRHS >= 0.
2908 --
2909 -- AP (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N*(N+1)/2)
2910 -- On entry, the upper or lower triangle of the symmetric matrix
2911 -- A, packed columnwise in a linear array. The j-th column of A
2912 -- is stored in the array AP as follows:
2913 -- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
2914 -- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
2915 -- See below for further details.
2916 --
2917 -- On exit, if INFO = 0, the factor U or L from the Cholesky
2918 -- factorization A = U**T*U or A = L*L**T, in the same storage
2919 -- format as A.
2920 --
2921 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
2922 -- On entry, the N-by-NRHS right hand side matrix B.
2923 -- On exit, if INFO = 0, the N-by-NRHS solution matrix X.
2924 --
2925 -- LDB (input) INTEGER
2926 -- The leading dimension of the array B. LDB >= max(1,N).
2927 --
2928 -- INFO (output) INTEGER
2929 -- = 0: successful exit
2930 -- < 0: if INFO = -i, the i-th argument had an illegal value
2931 -- > 0: if INFO = i, the leading minor of order i of A is not
2932 -- positive definite, so the factorization could not be
2933 -- completed, and the solution has not been computed.
2934 --
2935 -- PACK - (optional) FLAG
2936 -- The packing of the matricies:
2937 -- 'C': column-major (default)
2938 -- 'R': row-major
2939
2940 PROCEDURE lapack_ppsv (uplo IN flag,
2944 b IN OUT utl_nla_array_dbl,
2941 n IN POSITIVEN,
2942 nrhs IN POSITIVEN,
2943 ap IN OUT utl_nla_array_dbl,
2945 ldb IN POSITIVEN,
2946 info OUT integer,
2947 pack IN flag DEFAULT 'C');
2948
2949 PROCEDURE lapack_ppsv (uplo IN flag,
2950 n IN POSITIVEN,
2951 nrhs IN POSITIVEN,
2952 ap IN OUT UTL_NLA_ARRAY_FLT,
2953 b IN OUT UTL_NLA_ARRAY_FLT,
2954 ldb IN POSITIVEN,
2955 info OUT integer,
2956 pack IN flag DEFAULT 'C');
2957
2958 --
2959 -- Purpose
2960 -- =======
2961 --
2962 -- LAPACK_PBSV computes the solution to a real system of linear equations
2963 -- A * X = B,
2964 -- where A is an N-by-N symmetric positive definite band matrix and X
2965 -- and B are N-by-NRHS matrices.
2966 --
2967 -- The Cholesky decomposition is used to factor A as
2968 -- A = U**T * U, if UPLO = 'U', or
2969 -- A = L * L**T, if UPLO = 'L',
2970 -- where U is an upper triangular band matrix, and L is a lower
2971 -- triangular band matrix, with the same number of superdiagonals or
2972 -- subdiagonals as A. The factored form of A is then used to solve the
2973 -- system of equations A * X = B.
2974 --
2975 -- Arguments
2976 -- =========
2977 --
2978 -- UPLO (input) FLAG
2979 -- = 'U': Upper triangle of A is stored;
2980 -- = 'L': Lower triangle of A is stored.
2981 --
2982 -- N (input) INTEGER
2983 -- The number of linear equations, i.e., the order of the
2984 -- matrix A. N >= 0.
2985 --
2986 -- KD (input) INTEGER
2987 -- The number of superdiagonals of the matrix A if UPLO = 'U',
2988 -- or the number of subdiagonals if UPLO = 'L'. KD >= 0.
2989 --
2990 -- NRHS (input) INTEGER
2991 -- The number of right hand sides, i.e., the number of columns
2992 -- of the matrix B. NRHS >= 0.
2993 --
2994 -- AB (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDAB,N)
2995 -- On entry, the upper or lower triangle of the symmetric band
2996 -- matrix A, stored in the first KD+1 rows of the array. The
2997 -- j-th column of A is stored in the j-th column of the array AB
2998 -- as follows:
2999 -- if UPLO = 'U', AB(KD+1+i-j,j) = A(i,j) for max(1,j-KD)<=i<=j;
3000 -- if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(N,j+KD).
3001 -- See below for further details.
3002 --
3003 -- On exit, if INFO = 0, the triangular factor U or L from the
3004 -- Cholesky factorization A = U**T*U or A = L*L**T of the band
3005 -- matrix A, in the same storage format as A.
3006 --
3007 -- LDAB (input) INTEGER
3008 -- The leading dimension of the array AB. LDAB >= KD+1.
3009 --
3010 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
3011 -- On entry, the N-by-NRHS right hand side matrix B.
3012 -- On exit, if INFO = 0, the N-by-NRHS solution matrix X.
3013 --
3014 -- LDB (input) INTEGER
3015 -- The leading dimension of the array B. LDB >= max(1,N).
3016 --
3017 -- INFO (output) INTEGER
3018 -- = 0: successful exit
3019 -- < 0: if INFO = -i, the i-th argument had an illegal value
3020 -- > 0: if INFO = i, the leading minor of order i of A is not
3021 -- positive definite, so the factorization could not be
3022 -- completed, and the solution has not been computed.
3023 -- PACK - (optional) FLAG
3024 -- The packing of the matricies:
3025 -- 'C': column-major (default)
3026 -- 'R': row-major
3027
3028 PROCEDURE lapack_pbsv (uplo IN flag,
3029 n IN POSITIVEN,
3030 kd IN NATURALN,
3031 nrhs IN POSITIVEN,
3032 ab IN OUT utl_nla_array_dbl,
3033 ldab IN POSITIVEN,
3034 b IN OUT utl_nla_array_dbl,
3035 ldb IN POSITIVEN,
3036 info OUT integer,
3037 pack IN flag DEFAULT 'C');
3038
3039 PROCEDURE lapack_pbsv (uplo IN flag,
3040 n IN POSITIVEN,
3041 kd IN NATURALN,
3042 nrhs IN POSITIVEN,
3043 ab IN OUT UTL_NLA_ARRAY_FLT,
3044 ldab IN POSITIVEN,
3045 b IN OUT UTL_NLA_ARRAY_FLT,
3046 ldb IN POSITIVEN,
3047 info OUT integer,
3048 pack IN flag DEFAULT 'C');
3049
3050 --
3051 -- Purpose
3052 -- =======
3053 --
3054 -- SPTSV computes the solution to a real system of linear equations
3055 -- A*X = B, where A is an N-by-N symmetric positive definite tridiagonal
3056 -- matrix, and X and B are N-by-NRHS matrices.
3057 --
3058 -- A is factored as A = L*D*L**T, and the factored form of A is then
3062 -- =========
3059 -- used to solve the system of equations.
3060 --
3061 -- Arguments
3063 --
3064 -- N (input) INTEGER
3065 -- The order of the matrix A. N >= 0.
3066 --
3067 -- NRHS (input) INTEGER
3068 -- The number of right hand sides, i.e., the number of columns
3069 -- of the matrix B. NRHS >= 0.
3070 --
3071 -- D (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3072 -- On entry, the n diagonal elements of the tridiagonal matrix
3073 -- A. On exit, the n diagonal elements of the diagonal matrix
3074 -- D from the factorization A = L*D*L**T.
3075 --
3076 -- E (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N-1)
3077 -- On entry, the (n-1) subdiagonal elements of the tridiagonal
3078 -- matrix A. On exit, the (n-1) subdiagonal elements of the
3079 -- unit bidiagonal factor L from the L*D*L**T factorization of
3080 -- A. (E can also be regarded as the superdiagonal of the unit
3081 -- bidiagonal factor U from the U**T*D*U factorization of A.)
3082 --
3083 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
3084 -- On entry, the N-by-NRHS right hand side matrix B.
3085 -- On exit, if INFO = 0, the N-by-NRHS solution matrix X.
3086 --
3087 -- LDB (input) INTEGER
3088 -- The leading dimension of the array B. LDB >= max(1,N).
3089 --
3090 -- INFO (output) INTEGER
3091 -- = 0: successful exit
3092 -- < 0: if INFO = -i, the i-th argument had an illegal value
3093 -- > 0: if INFO = i, the leading minor of order i is not
3094 -- positive definite, and the solution has not been
3095 -- computed. The factorization has not been completed
3096 -- unless i = N.
3097 -- PACK - (optional) FLAG
3098 -- The packing of the matricies:
3099 -- 'C': column-major (default)
3100 -- 'R': row-major
3101
3102 PROCEDURE lapack_ptsv (n IN POSITIVEN,
3103 nrhs IN POSITIVEN,
3104 d IN OUT utl_nla_array_dbl,
3105 e IN OUT utl_nla_array_dbl,
3106 b IN OUT utl_nla_array_dbl,
3107 ldb IN POSITIVEN,
3108 info OUT integer,
3109 pack IN flag DEFAULT 'C');
3110
3111 PROCEDURE lapack_ptsv (n IN POSITIVEN,
3112 nrhs IN POSITIVEN,
3113 d IN OUT UTL_NLA_ARRAY_FLT,
3114 e IN OUT UTL_NLA_ARRAY_FLT,
3115 b IN OUT UTL_NLA_ARRAY_FLT,
3116 ldb IN POSITIVEN,
3117 info OUT integer,
3118 pack IN flag DEFAULT 'C');
3119
3120 --
3121 -- Purpose
3122 -- =======
3123 --
3124 -- LAPACK_SYSV computes the solution to a real system of linear equations
3125 -- A * X = B,
3126 -- where A is an N-by-N symmetric matrix and X and B are N-by-NRHS
3127 -- matrices.
3128 --
3129 -- The diagonal pivoting method is used to factor A as
3130 -- A = U * D * U**T, if UPLO = 'U', or
3131 -- A = L * D * L**T, if UPLO = 'L',
3132 -- where U (or L) is a product of permutation and unit upper (lower)
3133 -- triangular matrices, and D is symmetric and block diagonal with
3134 -- 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then
3135 -- used to solve the system of equations A * X = B.
3136 --
3137 -- Arguments
3138 -- =========
3139 --
3140 -- UPLO (input) FLAG
3141 -- = 'U': Upper triangle of A is stored;
3142 -- = 'L': Lower triangle of A is stored.
3143 --
3144 -- N (input) INTEGER
3145 -- The number of linear equations, i.e., the order of the
3146 -- matrix A. N >= 0.
3147 --
3148 -- NRHS (input) INTEGER
3149 -- The number of right hand sides, i.e., the number of columns
3150 -- of the matrix B. NRHS >= 0.
3151 --
3152 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA,N)
3153 -- On entry, the symmetric matrix A. If UPLO = 'U', the leading
3154 -- N-by-N upper triangular part of A contains the upper
3155 -- triangular part of the matrix A, and the strictly lower
3156 -- triangular part of A is not referenced. If UPLO = 'L', the
3157 -- leading N-by-N lower triangular part of A contains the lower
3158 -- triangular part of the matrix A, and the strictly upper
3159 -- triangular part of A is not referenced.
3160 --
3161 -- On exit, if INFO = 0, the block diagonal matrix D and the
3162 -- multipliers used to obtain the factor U or L from the
3163 -- factorization A = U*D*U**T or A = L*D*L**T as computed by
3164 -- SSYTRF.
3165 --
3166 -- LDA (input) INTEGER
3167 -- The leading dimension of the array A. LDA >= max(1,N).
3168 --
3169 -- IPIV (output) INTEGER array, dimension (N)
3170 -- Details of the interchanges and the block structure of D, as
3171 -- determined by SSYTRF. If IPIV(k) > 0, then rows and columns
3172 -- k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1
3176 -- IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and
3173 -- diagonal block. If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,
3174 -- then rows and columns k-1 and -IPIV(k) were interchanged and
3175 -- D(k-1:k,k-1:k) is a 2-by-2 diagonal block. If UPLO = 'L' and
3177 -- -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2
3178 -- diagonal block.
3179 --
3180 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
3181 -- On entry, the N-by-NRHS right hand side matrix B.
3182 -- On exit, if INFO = 0, the N-by-NRHS solution matrix X.
3183 --
3184 -- LDB (input) INTEGER
3185 -- The leading dimension of the array B. LDB >= max(1,N).
3186 --
3187 -- INFO (output) INTEGER
3188 -- = 0: successful exit
3189 -- < 0: if INFO = -i, the i-th argument had an illegal value
3190 -- > 0: if INFO = i, D(i,i) is exactly zero. The factorization
3191 -- has been completed, but the block diagonal matrix D is
3192 -- exactly singular, so the solution could not be computed.
3193 -- PACK - (optional) FLAG
3194 -- The packing of the matricies:
3195 -- 'C': column-major (default)
3196 -- 'R': row-major
3197
3198 PROCEDURE lapack_sysv (uplo IN flag,
3199 n IN POSITIVEN,
3200 nrhs IN POSITIVEN,
3201 a IN OUT utl_nla_array_dbl,
3202 lda IN POSITIVEN,
3203 ipiv IN OUT UTL_NLA_ARRAY_INT,
3204 b IN OUT utl_nla_array_dbl,
3205 ldb IN POSITIVEN,
3206 info OUT integer,
3207 pack IN flag DEFAULT 'C');
3208
3209 PROCEDURE lapack_sysv (uplo IN flag,
3210 n IN POSITIVEN,
3211 nrhs IN POSITIVEN,
3212 a IN OUT UTL_NLA_ARRAY_FLT,
3213 lda IN POSITIVEN,
3214 ipiv IN OUT UTL_NLA_ARRAY_INT,
3215 b IN OUT UTL_NLA_ARRAY_FLT,
3216 ldb IN POSITIVEN,
3217 info OUT integer,
3218 pack IN flag DEFAULT 'C');
3219
3220 --
3221 -- Purpose
3222 -- =======
3223 --
3224 -- LAPACK_SPSV computes the solution to a real system of linear equations
3225 -- A * X = B,
3226 -- where A is an N-by-N symmetric matrix stored in packed format and X
3227 -- and B are N-by-NRHS matrices.
3228 --
3229 -- The diagonal pivoting method is used to factor A as
3230 -- A = U * D * U**T, if UPLO = 'U', or
3231 -- A = L * D * L**T, if UPLO = 'L',
3232 -- where U (or L) is a product of permutation and unit upper (lower)
3233 -- triangular matrices, D is symmetric and block diagonal with 1-by-1
3234 -- and 2-by-2 diagonal blocks. The factored form of A is then used to
3235 -- solve the system of equations A * X = B.
3236 --
3237 -- Arguments
3238 -- =========
3239 --
3240 -- UPLO (input) FLAG
3241 -- = 'U': Upper triangle of A is stored;
3242 -- = 'L': Lower triangle of A is stored.
3243 --
3244 -- N (input) INTEGER
3245 -- The number of linear equations, i.e., the order of the
3246 -- matrix A. N >= 0.
3247 --
3248 -- NRHS (input) INTEGER
3249 -- The number of right hand sides, i.e., the number of columns
3250 -- of the matrix B. NRHS >= 0.
3251 --
3252 -- AP (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N*(N+1)/2)
3253 -- On entry, the upper or lower triangle of the symmetric matrix
3254 -- A, packed columnwise in a linear array. The j-th column of A
3255 -- is stored in the array AP as follows:
3256 -- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
3257 -- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
3258 -- See below for further details.
3259 --
3260 -- On exit, the block diagonal matrix D and the multipliers used
3261 -- to obtain the factor U or L from the factorization
3262 -- A = U*D*U**T or A = L*D*L**T as computed by SSPTRF, stored as
3263 -- a packed triangular matrix in the same storage format as A.
3264 --
3265 -- IPIV (output) INTEGER array, dimension (N)
3266 -- Details of the interchanges and the block structure of D, as
3267 -- determined by SSPTRF. If IPIV(k) > 0, then rows and columns
3268 -- k and IPIV(k) were interchanged, and D(k,k) is a 1-by-1
3269 -- diagonal block. If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0,
3270 -- then rows and columns k-1 and -IPIV(k) were interchanged and
3271 -- D(k-1:k,k-1:k) is a 2-by-2 diagonal block. If UPLO = 'L' and
3272 -- IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and
3273 -- -IPIV(k) were interchanged and D(k:k+1,k:k+1) is a 2-by-2
3274 -- diagonal block.
3275 --
3276 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
3277 -- On entry, the N-by-NRHS right hand side matrix B.
3278 -- On exit, if INFO = 0, the N-by-NRHS solution matrix X.
3279 --
3280 -- LDB (input) INTEGER
3281 -- The leading dimension of the array B. LDB >= max(1,N).
3282 --
3283 -- INFO (output) INTEGER
3287 -- has been completed, but the block diagonal matrix D is
3284 -- = 0: successful exit
3285 -- < 0: if INFO = -i, the i-th argument had an illegal value
3286 -- > 0: if INFO = i, D(i,i) is exactly zero. The factorization
3288 -- exactly singular, so the solution could not be
3289 -- computed.
3290 -- PACK - (optional) FLAG
3291 -- The packing of the matricies:
3292 -- 'C': column-major (default)
3293 -- 'R': row-major
3294
3295 PROCEDURE lapack_spsv (uplo IN flag,
3296 n IN POSITIVEN,
3297 nrhs IN POSITIVEN,
3298 ap IN OUT utl_nla_array_dbl,
3299 ipiv IN OUT UTL_NLA_ARRAY_INT,
3300 b IN OUT utl_nla_array_dbl,
3301 ldb IN POSITIVEN,
3302 info OUT integer,
3303 pack IN flag DEFAULT 'C');
3304
3305 PROCEDURE lapack_spsv (uplo IN flag,
3306 n IN POSITIVEN,
3307 nrhs IN POSITIVEN,
3308 ap IN OUT UTL_NLA_ARRAY_FLT,
3309 ipiv IN OUT UTL_NLA_ARRAY_INT,
3310 b IN OUT UTL_NLA_ARRAY_FLT,
3311 ldb IN POSITIVEN,
3312 info OUT integer,
3313 pack IN flag DEFAULT 'C');
3314
3315 -- ----------------------------------------------------- --
3316 -- LAPACK Driver Routines: LLS and Eigenvalue Problems --
3317 -- ----------------------------------------------------- --
3318
3319 -- [> LLS Problems <]
3320
3321 --
3322 -- Purpose
3323 -- =======
3324 --
3325 -- LAPACK_GELS solves overdetermined or underdetermined real linear systems
3326 -- involving an M-by-N matrix A, or its transpose, using a QR or LQ
3327 -- factorization of A. It is assumed that A has full rank.
3328 --
3329 -- The following options are provided:
3330 --
3331 -- 1. If TRANS = 'N' and m >= n: find the least squares solution of
3332 -- an overdetermined system, i.e., solve the least squares problem
3333 -- minimize || B - A*X ||.
3334 --
3335 -- 2. If TRANS = 'N' and m < n: find the minimum norm solution of
3336 -- an underdetermined system A * X = B.
3337 --
3338 -- 3. If TRANS = 'T' and m >= n: find the minimum norm solution of
3339 -- an undetermined system A**T * X = B.
3340 --
3341 -- 4. If TRANS = 'T' and m < n: find the least squares solution of
3342 -- an overdetermined system, i.e., solve the least squares problem
3343 -- minimize || B - A**T * X ||.
3344 --
3345 -- Several right hand side vectors b and solution vectors x can be
3346 -- handled in a single call; they are stored as the columns of the
3347 -- M-by-NRHS right hand side matrix B and the N-by-NRHS solution
3348 -- matrix X.
3349 --
3350 -- Arguments
3351 -- =========
3352 --
3353 -- TRANS (input) CHARACTER
3354 -- = 'N': the linear system involves A;
3355 -- = 'T': the linear system involves A**T.
3356 --
3357 -- M (input) INTEGER
3358 -- The number of rows of the matrix A. M >= 0.
3359 --
3360 -- N (input) INTEGER
3361 -- The number of columns of the matrix A. N >= 0.
3362 --
3363 -- NRHS (input) INTEGER
3364 -- The number of right hand sides, i.e., the number of
3365 -- columns of the matrices B and X. NRHS >=0.
3366 --
3367 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA,N)
3368 -- On entry, the M-by-N matrix A.
3369 -- On exit,
3370 -- if M >= N, A is overwritten by details of its QR
3371 -- factorization as returned by SGEQRF;
3372 -- if M < N, A is overwritten by details of its LQ
3373 -- factorization as returned by SGELQF.
3374 --
3375 -- LDA (input) INTEGER
3376 -- The leading dimension of the array A. LDA >= max(1,M).
3377 --
3378 -- B (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDB,NRHS)
3379 -- On entry, the matrix B of right hand side vectors, stored
3380 -- columnwise; B is M-by-NRHS if TRANS = 'N', or N-by-NRHS
3381 -- if TRANS = 'T'.
3382 -- On exit, B is overwritten by the solution vectors, stored
3383 -- columnwise:
3384 -- if TRANS = 'N' and m >= n, rows 1 to n of B contain the least
3385 -- squares solution vectors; the residual sum of squares for the
3386 -- solution in each column is given by the sum of squares of
3387 -- elements N+1 to M in that column;
3388 -- if TRANS = 'N' and m < n, rows 1 to N of B contain the
3389 -- minimum norm solution vectors;
3390 -- if TRANS = 'T' and m >= n, rows 1 to M of B contain the
3391 -- minimum norm solution vectors;
3392 -- if TRANS = 'T' and m < n, rows 1 to M of B contain the
3393 -- least squares solution vectors; the residual sum of squares
3394 -- for the solution in each column is given by the sum of
3395 -- squares of elements M+1 to N in that column.
3396 --
3397 -- LDB (input) INTEGER
3398 -- The leading dimension of the array B. LDB >= MAX(1,M,N).
3399 --
3403 --
3400 -- INFO (output) INTEGER
3401 -- = 0: successful exit
3402 -- < 0: if INFO = -i, the i-th argument had an illegal value
3404 -- PACK (optional) FLAG
3405 -- The packing of the matricies:
3406 -- 'C': column-major (default)
3407 -- 'R': row-major
3408
3409 PROCEDURE lapack_gels(trans IN flag,
3410 m IN POSITIVEN,
3411 n IN POSITIVEN,
3412 nrhs IN POSITIVEN,
3413 a IN OUT utl_nla_array_dbl,
3414 lda IN POSITIVEN,
3415 b IN OUT utl_nla_array_dbl,
3416 ldb IN POSITIVEN,
3417 info OUT integer,
3418 pack IN flag DEFAULT 'C');
3419
3420 PROCEDURE lapack_gels(trans IN flag,
3421 m IN POSITIVEN,
3422 n IN POSITIVEN,
3423 nrhs IN POSITIVEN,
3424 a IN OUT UTL_NLA_ARRAY_FLT,
3425 lda IN POSITIVEN,
3426 b IN OUT UTL_NLA_ARRAY_FLT,
3427 ldb IN POSITIVEN,
3428 info OUT integer,
3429 pack IN flag DEFAULT 'C');
3430
3431 -- [> Symmetric Eigenproblems <]
3432
3433 --
3434 -- Purpose
3435 -- =======
3436 --
3437 -- LAPACK_SSYEV computes all eigenvalues and, optionally, eigenvectors of a
3438 -- real symmetric matrix A.
3439 --
3440 -- Arguments
3441 -- =========
3442 --
3443 -- JOBZ (input) FLAG
3444 -- = 'N': Compute eigenvalues only;
3445 -- = 'V': Compute eigenvalues and eigenvectors.
3446 --
3447 -- UPLO (input) FLAG
3448 -- = 'U': Upper triangle of A is stored;
3449 -- = 'L': Lower triangle of A is stored.
3450 --
3451 -- N (input) INTEGER
3452 -- The order of the matrix A. N >= 0.
3453 --
3454 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA, N)
3455 -- On entry, the symmetric matrix A. If UPLO = 'U', the
3456 -- leading N-by-N upper triangular part of A contains the
3457 -- upper triangular part of the matrix A. If UPLO = 'L',
3458 -- the leading N-by-N lower triangular part of A contains
3459 -- the lower triangular part of the matrix A.
3460 -- On exit, if JOBZ = 'V', then if INFO = 0, A contains the
3461 -- orthonormal eigenvectors of the matrix A.
3462 -- If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')
3463 -- or the upper triangle (if UPLO='U') of A, including the
3464 -- diagonal, is destroyed.
3465 --
3466 -- LDA (input) INTEGER
3467 -- The leading dimension of the array A. LDA >= max(1,N).
3468 --
3469 -- W (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3470 -- If INFO = 0, the eigenvalues in ascending order.
3471 --
3472 -- INFO (output) INTEGER
3473 -- = 0: successful exit
3474 -- < 0: if INFO = -i, the i-th argument had an illegal value
3475 -- > 0: if INFO = i, the algorithm failed to converge; i
3476 -- off-diagonal elements of an intermediate tridiagonal
3477 -- form did not converge to zero.
3478 --
3479 -- PACK (optional) FLAG
3480 -- The packing of the matricies:
3481 -- 'C': column-major (default)
3482 -- 'R': row-major
3483
3484 PROCEDURE lapack_syev(jobz IN flag,
3485 uplo IN flag,
3486 n IN POSITIVEN,
3487 a IN OUT utl_nla_array_dbl,
3488 lda IN POSITIVEN,
3489 w IN OUT utl_nla_array_dbl,
3490 info OUT integer,
3491 pack IN flag DEFAULT 'C');
3492
3493 PROCEDURE lapack_syev(jobz IN flag,
3494 uplo IN flag,
3495 n IN POSITIVEN,
3496 a IN OUT UTL_NLA_ARRAY_FLT,
3497 lda IN POSITIVEN,
3498 w IN OUT UTL_NLA_ARRAY_FLT,
3499 info OUT integer,
3500 pack IN flag DEFAULT 'C');
3501
3502 --
3503 -- Purpose
3504 -- =======
3505 --
3506 -- LAPACK_SYEVD computes all eigenvalues and, optionally, eigenvectors of a
3507 -- real symmetric matrix A. If eigenvectors are desired, it uses a
3508 -- divide and conquer algorithm.
3509 --
3510 -- The divide and conquer algorithm makes very mild assumptions about
3511 -- floating point arithmetic.
3512 --
3513 -- Arguments
3514 -- =========
3515 --
3516 -- JOBZ (input) FLAG
3517 -- = 'N': Compute eigenvalues only;
3518 -- = 'V': Compute eigenvalues and eigenvectors.
3519 --
3520 -- UPLO (input) FLAG
3521 -- = 'U': Upper triangle of A is stored;
3522 -- = 'L': Lower triangle of A is stored.
3523 --
3524 -- N (input) INTEGER
3525 -- The order of the matrix A. N >= 0.
3526 --
3527 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA, N)
3531 -- the leading N-by-N lower triangular part of A contains
3528 -- On entry, the symmetric matrix A. If UPLO = 'U', the
3529 -- leading N-by-N upper triangular part of A contains the
3530 -- upper triangular part of the matrix A. If UPLO = 'L',
3532 -- the lower triangular part of the matrix A.
3533 -- On exit, if JOBZ = 'V', then if INFO = 0, A contains the
3534 -- orthonormal eigenvectors of the matrix A.
3535 -- If JOBZ = 'N', then on exit the lower triangle (if UPLO='L')
3536 -- or the upper triangle (if UPLO='U') of A, including the
3537 -- diagonal, is destroyed.
3538 --
3539 -- LDA (input) INTEGER
3540 -- The leading dimension of the array A. LDA >= max(1,N).
3541 --
3542 -- W (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3543 -- If INFO = 0, the eigenvalues in ascending order.
3544 --
3545 -- INFO (output) INTEGER
3546 -- = 0: successful exit
3547 -- < 0: if INFO = -i, the i-th argument had an illegal value
3548 -- > 0: if INFO = i, the algorithm failed to converge; i
3549 -- off-diagonal elements of an intermediate tridiagonal
3550 -- form did not converge to zero.
3551 --
3552 -- PACK (optional) FLAG
3553 -- The packing of the matricies:
3554 -- 'C': column-major (default)
3555 -- 'R': row-major
3556
3557 PROCEDURE lapack_syevd(jobz IN flag,
3558 uplo IN flag,
3559 n IN POSITIVEN,
3560 a IN OUT utl_nla_array_dbl,
3561 lda IN POSITIVEN,
3562 w IN OUT utl_nla_array_dbl,
3563 info OUT integer,
3564 pack IN flag DEFAULT 'C');
3565
3566 PROCEDURE lapack_syevd(jobz IN flag,
3567 uplo IN flag,
3568 n IN POSITIVEN,
3569 a IN OUT UTL_NLA_ARRAY_FLT,
3570 lda IN POSITIVEN,
3571 w IN OUT UTL_NLA_ARRAY_FLT,
3572 info OUT integer,
3573 pack IN flag DEFAULT 'C');
3574
3575 --
3576 -- Purpose
3577 -- =======
3578 --
3579 -- LAPACK_SPEV computes all the eigenvalues and, optionally, eigenvectors of a
3580 -- real symmetric matrix A in packed storage.
3581 --
3582 -- Arguments
3583 -- =========
3584 --
3585 -- JOBZ (input) FLAG
3586 -- = 'N': Compute eigenvalues only;
3587 -- = 'V': Compute eigenvalues and eigenvectors.
3588 --
3589 -- UPLO (input) FLAG
3590 -- = 'U': Upper triangle of A is stored;
3591 -- = 'L': Lower triangle of A is stored.
3592 --
3593 -- N (input) INTEGER
3594 -- The order of the matrix A. N >= 0.
3595 --
3596 -- AP (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N*(N+1)/2)
3597 -- On entry, the upper or lower triangle of the symmetric matrix
3598 -- A, packed columnwise in a linear array. The j-th column of A
3599 -- is stored in the array AP as follows:
3600 -- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
3601 -- if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
3602 --
3603 -- On exit, AP is overwritten by values generated during the
3604 -- reduction to tridiagonal form. If UPLO = 'U', the diagonal
3605 -- and first superdiagonal of the tridiagonal matrix T overwrite
3606 -- the corresponding elements of A, and if UPLO = 'L', the
3607 -- diagonal and first subdiagonal of T overwrite the
3608 -- corresponding elements of A.
3609 --
3610 -- W (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3611 -- If INFO = 0, the eigenvalues in ascending order.
3612 --
3613 -- Z (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDZ, N)
3614 -- If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
3615 -- eigenvectors of the matrix A, with the i-th column of Z
3616 -- holding the eigenvector associated with W(i).
3617 -- If JOBZ = 'N', then Z is not referenced.
3618 --
3619 -- LDZ (input) INTEGER
3620 -- The leading dimension of the array Z. LDZ >= 1, and if
3621 -- JOBZ = 'V', LDZ >= max(1,N).
3622 --
3623 -- INFO (output) INTEGER
3624 -- = 0: successful exit.
3625 -- < 0: if INFO = -i, the i-th argument had an illegal value.
3626 -- > 0: if INFO = i, the algorithm failed to converge; i
3627 -- off-diagonal elements of an intermediate tridiagonal
3628 -- form did not converge to zero.
3629 --
3630 -- PACK (optional) FLAG
3631 -- The packing of the matricies:
3632 -- 'C': column-major (default)
3633 -- 'R': row-major
3634
3635 PROCEDURE lapack_spev(jobz IN flag,
3636 uplo IN flag,
3637 n IN POSITIVEN,
3638 ap IN OUT utl_nla_array_dbl,
3639 w IN OUT utl_nla_array_dbl,
3640 z IN OUT utl_nla_array_dbl,
3641 ldz IN POSITIVEN,
3642 info OUT integer,
3646 uplo IN flag,
3643 pack IN flag DEFAULT 'C');
3644
3645 PROCEDURE lapack_spev(jobz IN flag,
3647 n IN POSITIVEN,
3648 ap IN OUT UTL_NLA_ARRAY_FLT,
3649 w IN OUT UTL_NLA_ARRAY_FLT,
3650 z IN OUT UTL_NLA_ARRAY_FLT,
3651 ldz IN POSITIVEN,
3652 info OUT integer,
3653 pack IN flag DEFAULT 'C');
3654
3655 --
3656 -- Purpose
3657 -- =======
3658 --
3659 -- LAPACK_SPEVD computes all the eigenvalues and, optionally, eigenvectors
3660 -- of a real symmetric matrix A in packed storage. If eigenvectors are
3661 -- desired, it uses a divide and conquer algorithm.
3662 --
3663 -- The divide and conquer algorithm makes very mild assumptions about
3664 -- floating point arithmetic.
3665 --
3666 -- Arguments
3667 -- =========
3668 --
3669 -- JOBZ (input) FLAG
3670 -- = 'N': Compute eigenvalues only;
3671 -- = 'V': Compute eigenvalues and eigenvectors.
3672 --
3673 -- UPLO (input) FLAG
3674 -- = 'U': Upper triangle of A is stored;
3675 -- = 'L': Lower triangle of A is stored.
3676 --
3677 -- N (input) INTEGER
3678 -- The order of the matrix A. N >= 0.
3679 --
3680 -- AP (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N*(N+1)/2)
3681 -- On entry, the upper or lower triangle of the symmetric matrix
3682 -- A, packed columnwise in a linear array. The j-th column of A
3683 -- is stored in the array AP as follows:
3684 -- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
3685 -- if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
3686 --
3687 -- On exit, AP is overwritten by values generated during the
3688 -- reduction to tridiagonal form. If UPLO = 'U', the diagonal
3689 -- and first superdiagonal of the tridiagonal matrix T overwrite
3690 -- the corresponding elements of A, and if UPLO = 'L', the
3691 -- diagonal and first subdiagonal of T overwrite the
3692 -- corresponding elements of A.
3693 --
3694 -- W (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3695 -- If INFO = 0, the eigenvalues in ascending order.
3696 --
3697 -- Z (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDZ, N)
3698 -- If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
3699 -- eigenvectors of the matrix A, with the i-th column of Z
3700 -- holding the eigenvector associated with W(i).
3701 -- If JOBZ = 'N', then Z is not referenced.
3702 --
3703 -- LDZ (input) INTEGER
3704 -- The leading dimension of the array Z. LDZ >= 1, and if
3705 -- JOBZ = 'V', LDZ >= max(1,N).
3706 --
3707 -- INFO (output) INTEGER
3708 -- = 0: successful exit
3709 -- < 0: if INFO = -i, the i-th argument had an illegal value.
3710 -- > 0: if INFO = i, the algorithm failed to converge; i
3711 -- off-diagonal elements of an intermediate tridiagonal
3712 -- form did not converge to zero.
3713 --
3714 -- PACK (optional) FLAG
3715 -- The packing of the matricies:
3716 -- 'C': column-major (default)
3717 -- 'R': row-major
3718
3719 PROCEDURE lapack_spevd(jobz IN flag,
3720 uplo IN flag,
3721 n IN POSITIVEN,
3722 ap IN OUT utl_nla_array_dbl,
3723 w IN OUT utl_nla_array_dbl,
3724 z IN OUT utl_nla_array_dbl,
3725 ldz IN POSITIVEN,
3726 info OUT integer,
3727 pack IN flag DEFAULT 'C');
3728
3729 PROCEDURE lapack_spevd(jobz IN flag,
3730 uplo IN flag,
3731 n IN POSITIVEN,
3732 ap IN OUT UTL_NLA_ARRAY_FLT,
3733 w IN OUT UTL_NLA_ARRAY_FLT,
3734 z IN OUT UTL_NLA_ARRAY_FLT,
3735 ldz IN POSITIVEN,
3736 info OUT integer,
3737 pack IN flag DEFAULT 'C');
3738
3739 --
3740 -- Purpose
3741 -- =======
3742 --
3743 -- SSBEV computes all the eigenvalues and, optionally, eigenvectors of
3744 -- a real symmetric band matrix A.
3745 --
3746 -- Arguments
3747 -- =========
3748 --
3749 -- JOBZ (input) FLAG
3750 -- = 'N': Compute eigenvalues only;
3751 -- = 'V': Compute eigenvalues and eigenvectors.
3752 --
3753 -- UPLO (input) FLAG
3754 -- = 'U': Upper triangle of A is stored;
3755 -- = 'L': Lower triangle of A is stored.
3756 --
3757 -- N (input) INTEGER
3758 -- The order of the matrix A. N >= 0.
3759 --
3760 -- KD (input) INTEGER
3761 -- The number of superdiagonals of the matrix A if UPLO = 'U',
3765 -- On entry, the upper or lower triangle of the symmetric band
3762 -- or the number of subdiagonals if UPLO = 'L'. KD >= 0.
3763 --
3764 -- AB (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDAB, N)
3766 -- matrix A, stored in the first KD+1 rows of the array. The
3767 -- j-th column of A is stored in the j-th column of the array AB
3768 -- as follows:
3769 -- if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
3770 -- if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
3771 --
3772 -- On exit, AB is overwritten by values generated during the
3773 -- reduction to tridiagonal form. If UPLO = 'U', the first
3774 -- superdiagonal and the diagonal of the tridiagonal matrix T
3775 -- are returned in rows KD and KD+1 of AB, and if UPLO = 'L',
3776 -- the diagonal and first subdiagonal of T are returned in the
3777 -- first two rows of AB.
3778 --
3779 -- LDAB (input) INTEGER
3780 -- The leading dimension of the array AB. LDAB >= KD + 1.
3781 --
3782 -- W (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3783 -- If INFO = 0, the eigenvalues in ascending order.
3784 --
3785 -- Z (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDZ, N)
3786 -- If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
3787 -- eigenvectors of the matrix A, with the i-th column of Z
3788 -- holding the eigenvector associated with W(i).
3789 -- If JOBZ = 'N', then Z is not referenced.
3790 --
3791 -- LDZ (input) INTEGER
3792 -- The leading dimension of the array Z. LDZ >= 1, and if
3793 -- JOBZ = 'V', LDZ >= max(1,N).
3794 --
3795 -- INFO (output) INTEGER
3796 -- = 0: successful exit
3797 -- < 0: if INFO = -i, the i-th argument had an illegal value
3798 -- > 0: if INFO = i, the algorithm failed to converge; i
3799 -- off-diagonal elements of an intermediate tridiagonal
3800 -- form did not converge to zero.
3801 --
3802 -- PACK (optional) FLAG
3803 -- The packing of the matricies:
3804 -- 'C': column-major (default)
3805 -- 'R': row-major
3806
3807 PROCEDURE lapack_sbev(jobz IN flag,
3808 uplo IN flag,
3809 n IN POSITIVEN,
3810 kd IN NATURALN,
3811 ab IN OUT utl_nla_array_dbl,
3812 ldab IN POSITIVEN,
3813 w IN OUT utl_nla_array_dbl,
3814 z IN OUT utl_nla_array_dbl,
3815 ldz IN POSITIVEN,
3816 info OUT integer,
3817 pack IN flag DEFAULT 'C');
3818
3819 PROCEDURE lapack_sbev(jobz IN flag,
3820 uplo IN flag,
3821 n IN POSITIVEN,
3822 kd IN NATURALN,
3823 ab IN OUT UTL_NLA_ARRAY_FLT,
3824 ldab IN POSITIVEN,
3825 w IN OUT UTL_NLA_ARRAY_FLT,
3826 z IN OUT UTL_NLA_ARRAY_FLT,
3827 ldz IN POSITIVEN,
3828 info OUT integer,
3829 pack IN flag DEFAULT 'C');
3830
3831 --
3832 -- Purpose
3833 -- =======
3834 --
3835 -- LAPACK_SBEVD computes all the eigenvalues and, optionally, eigenvectors of
3836 -- a real symmetric band matrix A. If eigenvectors are desired, it uses
3837 -- a divide and conquer algorithm.
3838 --
3839 -- The divide and conquer algorithm makes very mild assumptions about
3840 -- floating point arithmetic.
3841 --
3842 -- Arguments
3843 -- =========
3844 --
3845 -- JOBZ (input) FLAG
3846 -- = 'N': Compute eigenvalues only;
3847 -- = 'V': Compute eigenvalues and eigenvectors.
3848 --
3849 -- UPLO (input) FLAG
3850 -- = 'U': Upper triangle of A is stored;
3851 -- = 'L': Lower triangle of A is stored.
3852 --
3853 -- N (input) INTEGER
3854 -- The order of the matrix A. N >= 0.
3855 --
3856 -- KD (input) INTEGER
3857 -- The number of superdiagonals of the matrix A if UPLO = 'U',
3858 -- or the number of subdiagonals if UPLO = 'L'. KD >= 0.
3859 --
3860 -- AB (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDAB, N)
3861 -- On entry, the upper or lower triangle of the symmetric band
3862 -- matrix A, stored in the first KD+1 rows of the array. The
3863 -- j-th column of A is stored in the j-th column of the array AB
3864 -- as follows:
3865 -- if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
3866 -- if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
3867 --
3868 -- On exit, AB is overwritten by values generated during the
3869 -- reduction to tridiagonal form. If UPLO = 'U', the first
3870 -- superdiagonal and the diagonal of the tridiagonal matrix T
3871 -- are returned in rows KD and KD+1 of AB, and if UPLO = 'L',
3872 -- the diagonal and first subdiagonal of T are returned in the
3873 -- first two rows of AB.
3874 --
3875 -- LDAB (input) INTEGER
3879 -- If INFO = 0, the eigenvalues in ascending order.
3876 -- The leading dimension of the array AB. LDAB >= KD + 1.
3877 --
3878 -- W (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3880 --
3881 -- Z (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDZ, N)
3882 -- If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
3883 -- eigenvectors of the matrix A, with the i-th column of Z
3884 -- holding the eigenvector associated with W(i).
3885 -- If JOBZ = 'N', then Z is not referenced.
3886 --
3887 -- LDZ (input) INTEGER
3888 -- The leading dimension of the array Z. LDZ >= 1, and if
3889 -- JOBZ = 'V', LDZ >= max(1,N).
3890 --
3891 -- INFO (output) INTEGER
3892 -- = 0: successful exit
3893 -- < 0: if INFO = -i, the i-th argument had an illegal value
3894 -- > 0: if INFO = i, the algorithm failed to converge; i
3895 -- off-diagonal elements of an intermediate tridiagonal
3896 -- form did not converge to zero.
3897 --
3898 -- PACK (optional) FLAG
3899 -- The packing of the matricies:
3900 -- 'C': column-major (default)
3901 -- 'R': row-major
3902
3903 PROCEDURE lapack_sbevd(jobz IN flag,
3904 uplo IN flag,
3905 n IN POSITIVEN,
3906 kd IN NATURALN,
3907 ab IN OUT utl_nla_array_dbl,
3908 ldab IN POSITIVEN,
3909 w IN OUT utl_nla_array_dbl,
3910 z IN OUT utl_nla_array_dbl,
3911 ldz IN POSITIVEN,
3912 info OUT integer,
3913 pack IN flag DEFAULT 'C');
3914
3915 PROCEDURE lapack_sbevd(jobz IN flag,
3916 uplo IN flag,
3917 n IN POSITIVEN,
3918 kd IN NATURALN,
3919 ab IN OUT UTL_NLA_ARRAY_FLT,
3920 ldab IN POSITIVEN,
3921 w IN OUT UTL_NLA_ARRAY_FLT,
3922 z IN OUT UTL_NLA_ARRAY_FLT,
3923 ldz IN POSITIVEN,
3924 info OUT integer,
3925 pack IN flag DEFAULT 'C');
3926
3927 --
3928 -- Purpose
3929 -- =======
3930 --
3931 -- LAPACK_STEV computes all eigenvalues and, optionally, eigenvectors of a
3932 -- real symmetric tridiagonal matrix A.
3933 --
3934 -- Arguments
3935 -- =========
3936 --
3937 -- JOBZ (input) FLAG
3938 -- = 'N': Compute eigenvalues only;
3939 -- = 'V': Compute eigenvalues and eigenvectors.
3940 --
3941 -- N (input) INTEGER
3942 -- The order of the matrix. N >= 0.
3943 --
3944 -- D (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3945 -- On entry, the n diagonal elements of the tridiagonal matrix
3946 -- A.
3947 -- On exit, if INFO = 0, the eigenvalues in ascending order.
3948 --
3949 -- E (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
3950 -- On entry, the (n-1) subdiagonal elements of the tridiagonal
3951 -- matrix A, stored in elements 1 to N-1 of E; E(N) need not
3952 -- be set, but is used by the routine.
3953 -- On exit, the contents of E are destroyed.
3954 --
3955 -- Z (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDZ, N)
3956 -- If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
3957 -- eigenvectors of the matrix A, with the i-th column of Z
3958 -- holding the eigenvector associated with D(i).
3959 -- If JOBZ = 'N', then Z is not referenced.
3960 --
3961 -- LDZ (input) INTEGER
3962 -- The leading dimension of the array Z. LDZ >= 1, and if
3963 -- JOBZ = 'V', LDZ >= max(1,N).
3964 --
3965 -- INFO (output) INTEGER
3966 -- = 0: successful exit
3967 -- < 0: if INFO = -i, the i-th argument had an illegal value
3968 -- > 0: if INFO = i, the algorithm failed to converge; i
3969 -- off-diagonal elements of E did not converge to zero.
3970 --
3971 -- PACK (optional) FLAG
3972 -- The packing of the matricies:
3973 -- 'C': column-major (default)
3974 -- 'R': row-major
3975
3976 PROCEDURE lapack_stev(jobz IN flag,
3977 n IN POSITIVEN,
3978 d IN OUT utl_nla_array_dbl,
3979 e IN OUT utl_nla_array_dbl,
3980 z IN OUT utl_nla_array_dbl,
3981 ldz IN POSITIVEN,
3982 info OUT integer,
3983 pack IN flag DEFAULT 'C');
3984
3985 PROCEDURE lapack_stev(jobz IN flag,
3986 n IN POSITIVEN,
3987 d IN OUT UTL_NLA_ARRAY_FLT,
3988 e IN OUT UTL_NLA_ARRAY_FLT,
3989 z IN OUT UTL_NLA_ARRAY_FLT,
3990 ldz IN POSITIVEN,
3991 info OUT integer,
3992 pack IN flag DEFAULT 'C');
3993
3994 --
3995 -- Purpose
3996 -- =======
3997 --
4001 --
3998 -- LAPACK_STEVD computes all eigenvalues and, optionally, eigenvectors of a
3999 -- real symmetric tridiagonal matrix. If eigenvectors are desired, it
4000 -- uses a divide and conquer algorithm.
4002 -- The divide and conquer algorithm makes very mild assumptions about
4003 -- floating point arithmetic.
4004 --
4005 -- Arguments
4006 -- =========
4007 --
4008 -- JOBZ (input) FLAG
4009 -- = 'N': Compute eigenvalues only;
4010 -- = 'V': Compute eigenvalues and eigenvectors.
4011 --
4012 -- N (input) INTEGER
4013 -- The order of the matrix. N >= 0.
4014 --
4015 -- D (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
4016 -- On entry, the n diagonal elements of the tridiagonal matrix
4017 -- A.
4018 -- On exit, if INFO = 0, the eigenvalues in ascending order.
4019 --
4020 -- E (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
4021 -- On entry, the (n-1) subdiagonal elements of the tridiagonal
4022 -- matrix A, stored in elements 1 to N-1 of E; E(N) need not
4023 -- be set, but is used by the routine.
4024 -- On exit, the contents of E are destroyed.
4025 --
4026 -- Z (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDZ, N)
4027 -- If JOBZ = 'V', then if INFO = 0, Z contains the orthonormal
4028 -- eigenvectors of the matrix A, with the i-th column of Z
4029 -- holding the eigenvector associated with D(i).
4030 -- If JOBZ = 'N', then Z is not referenced.
4031 --
4032 -- LDZ (input) INTEGER
4033 -- The leading dimension of the array Z. LDZ >= 1, and if
4034 -- JOBZ = 'V', LDZ >= max(1,N).
4035 --
4036 -- INFO (output) INTEGER
4037 -- = 0: successful exit
4038 -- < 0: if INFO = -i, the i-th argument had an illegal value
4039 -- > 0: if INFO = i, the algorithm failed to converge; i
4040 -- off-diagonal elements of E did not converge to zero.
4041 --
4042 -- PACK (optional) FLAG
4043 -- The packing of the matricies:
4044 -- 'C': column-major (default)
4045 -- 'R': row-major
4046
4047 PROCEDURE lapack_stevd(jobz IN flag,
4048 n IN POSITIVEN,
4049 d IN OUT utl_nla_array_dbl,
4050 e IN OUT utl_nla_array_dbl,
4051 z IN OUT utl_nla_array_dbl,
4052 ldz IN POSITIVEN,
4053 info OUT integer,
4054 pack IN flag DEFAULT 'C');
4055
4056 PROCEDURE lapack_stevd(jobz IN flag,
4057 n IN POSITIVEN,
4058 d IN OUT UTL_NLA_ARRAY_FLT,
4059 e IN OUT UTL_NLA_ARRAY_FLT,
4060 z IN OUT UTL_NLA_ARRAY_FLT,
4061 ldz IN POSITIVEN,
4062 info OUT integer,
4063 pack IN flag DEFAULT 'C');
4064
4065 -- [> Nonsymmetric Eigenproblems <]
4066
4067 --
4068 -- Purpose
4069 -- =======
4070 --
4071 -- LAPACK_GEES computes for an N-by-N real nonsymmetric matrix A, the
4072 -- eigenvalues, the real Schur form T, and, optionally, the matrix of
4073 -- Schur vectors Z. This gives the Schur factorization A = Z*T*(Z**T).
4074 --
4075 -- A matrix is in real Schur form if it is upper quasi-triangular with
4076 -- 1-by-1 and 2-by-2 blocks. 2-by-2 blocks will be standardized in the
4077 -- form
4078 -- [ a b ]
4079 -- [ c a ]
4080 --
4081 -- where b*c < 0. The eigenvalues of such a block are a +- sqrt(bc).
4082 --
4083 -- Arguments
4084 -- =========
4085 --
4086 -- JOBVS (input) FLAG
4087 -- = 'N': Schur vectors are not computed;
4088 -- = 'V': Schur vectors are computed.
4089 --
4090 -- N (input) INTEGER
4091 -- The order of the matrix A. N >= 0.
4092 --
4093 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA,N)
4094 -- On entry, the N-by-N matrix A.
4095 -- On exit, A has been overwritten by its real Schur form T.
4096 --
4097 -- LDA (input) INTEGER
4098 -- The leading dimension of the array A. LDA >= max(1,N).
4099 --
4100 -- WR (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
4101 -- WI (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
4102 -- WR and WI contain the real and imaginary parts,
4103 -- respectively, of the computed eigenvalues in the same order
4104 -- that they appear on the diagonal of the output Schur form T.
4105 -- Complex conjugate pairs of eigenvalues will appear
4106 -- consecutively with the eigenvalue having the positive
4107 -- imaginary part first.
4108 --
4109 -- VS (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDVS,N)
4110 -- If JOBVS = 'V', VS contains the orthogonal matrix Z of Schur
4111 -- vectors.
4112 -- If JOBVS = 'N', VS is not referenced.
4113 --
4114 -- LDVS (input) INTEGER
4115 -- The leading dimension of the array VS. LDVS >= 1; if
4116 -- JOBVS = 'V', LDVS >= N.
4117 --
4118 -- INFO (output) INTEGER
4119 -- = 0: successful exit
4123 -- eigenvalues; elements 1:ILO-1 and i+1:N of WR and WI
4120 -- < 0: if INFO = -i, the i-th argument had an illegal value.
4121 -- > 0: if INFO = i, and i is
4122 -- <= N: the QR algorithm failed to compute all the
4124 -- contain those eigenvalues which have converged; if
4125 -- JOBVS = 'V', VS contains the matrix which reduces A
4126 -- to its partially converged Schur form.
4127 --
4128 -- PACK (optional) FLAG
4129 -- The packing of the matricies:
4130 -- 'C': column-major (default)
4131 -- 'R': row-major
4132
4133 PROCEDURE lapack_gees(jobvs IN flag,
4134 n IN POSITIVEN,
4135 a IN OUT utl_nla_array_dbl,
4136 lda IN POSITIVEN,
4137 wr IN OUT utl_nla_array_dbl,
4138 wi IN OUT utl_nla_array_dbl,
4139 vs IN OUT utl_nla_array_dbl,
4140 ldvs IN POSITIVEN,
4141 info OUT integer,
4142 pack IN flag DEFAULT 'C');
4143
4144 PROCEDURE lapack_gees(jobvs IN flag,
4145 n IN POSITIVEN,
4146 a IN OUT UTL_NLA_ARRAY_FLT,
4147 lda IN POSITIVEN,
4148 wr IN OUT UTL_NLA_ARRAY_FLT,
4149 wi IN OUT UTL_NLA_ARRAY_FLT,
4150 vs IN OUT UTL_NLA_ARRAY_FLT,
4151 ldvs IN POSITIVEN,
4152 info OUT integer,
4153 pack IN flag DEFAULT 'C');
4154
4155 --
4156 -- Purpose
4157 -- =======
4158 --
4159 -- LAPACK_GEEV computes for an N-by-N real nonsymmetric matrix A, the
4160 -- eigenvalues and, optionally, the left and/or right eigenvectors.
4161 --
4162 -- The right eigenvector v(j) of A satisfies
4163 -- A * v(j) = lambda(j) * v(j)
4164 -- where lambda(j) is its eigenvalue.
4165 -- The left eigenvector u(j) of A satisfies
4166 -- u(j)**H * A = lambda(j) * u(j)**H
4167 -- where u(j)**H denotes the conjugate transpose of u(j).
4168 --
4169 -- The computed eigenvectors are normalized to have Euclidean norm
4170 -- equal to 1 and largest component real.
4171 --
4172 -- Arguments
4173 -- =========
4174 --
4175 -- JOBVL (input) FLAG
4176 -- = 'N': left eigenvectors of A are not computed;
4177 -- = 'V': left eigenvectors of A are computed.
4178 --
4179 -- JOBVR (input) FLAG
4180 -- = 'N': right eigenvectors of A are not computed;
4181 -- = 'V': right eigenvectors of A are computed.
4182 --
4183 -- N (input) INTEGER
4184 -- The order of the matrix A. N >= 0.
4185 --
4186 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA,N)
4187 -- On entry, the N-by-N matrix A.
4188 -- On exit, A has been overwritten.
4189 --
4190 -- LDA (input) INTEGER
4191 -- The leading dimension of the array A. LDA >= max(1,N).
4192 --
4193 -- WR (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
4194 -- WI (output) UTL_NLA_ARRAY_FLT/DBL, dimension (N)
4195 -- WR and WI contain the real and imaginary parts,
4196 -- respectively, of the computed eigenvalues. Complex
4197 -- conjugate pairs of eigenvalues appear consecutively
4198 -- with the eigenvalue having the positive imaginary part
4199 -- first.
4200 --
4201 -- VL (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDVL,N)
4202 -- If JOBVL = 'V', the left eigenvectors u(j) are stored one
4203 -- after another in the columns of VL, in the same order
4204 -- as their eigenvalues.
4205 -- If JOBVL = 'N', VL is not referenced.
4206 -- If the j-th eigenvalue is real, then u(j) = VL(:,j),
4207 -- the j-th column of VL.
4208 -- If the j-th and (j+1)-st eigenvalues form a complex
4209 -- conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and
4210 -- u(j+1) = VL(:,j) - i*VL(:,j+1).
4211 --
4212 -- LDVL (input) INTEGER
4213 -- The leading dimension of the array VL. LDVL >= 1; if
4214 -- JOBVL = 'V', LDVL >= N.
4215 --
4216 -- VR (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDVR,N)
4217 -- If JOBVR = 'V', the right eigenvectors v(j) are stored one
4218 -- after another in the columns of VR, in the same order
4219 -- as their eigenvalues.
4220 -- If JOBVR = 'N', VR is not referenced.
4221 -- If the j-th eigenvalue is real, then v(j) = VR(:,j),
4222 -- the j-th column of VR.
4223 -- If the j-th and (j+1)-st eigenvalues form a complex
4224 -- conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and
4225 -- v(j+1) = VR(:,j) - i*VR(:,j+1).
4226 --
4227 -- LDVR (input) INTEGER
4228 -- The leading dimension of the array VR. LDVR >= 1; if
4229 -- JOBVR = 'V', LDVR >= N.
4230 --
4231 -- INFO (output) INTEGER
4232 -- = 0: successful exit
4233 -- < 0: if INFO = -i, the i-th argument had an illegal value.
4234 -- > 0: if INFO = i, the QR algorithm failed to compute all the
4238 --
4235 -- eigenvalues, and no eigenvectors have been computed;
4236 -- elements i+1:N of WR and WI contain eigenvalues which
4237 -- have converged.
4239 -- PACK (optional) FLAG
4240 -- The packing of the matricies:
4241 -- 'C': column-major (default)
4242 -- 'R': row-major
4243
4244 PROCEDURE lapack_geev(jobvl IN flag,
4245 jobvr IN flag,
4246 n IN POSITIVEN,
4247 a IN OUT utl_nla_array_dbl,
4248 lda IN POSITIVEN,
4249 wr IN OUT utl_nla_array_dbl,
4250 wi IN OUT utl_nla_array_dbl,
4251 vl IN OUT utl_nla_array_dbl,
4252 ldvl IN POSITIVEN,
4253 vr IN OUT utl_nla_array_dbl,
4254 ldvr IN POSITIVEN,
4255 info OUT integer,
4256 pack IN flag DEFAULT 'C');
4257
4258 PROCEDURE lapack_geev(jobvl IN flag,
4259 jobvr IN flag,
4260 n IN POSITIVEN,
4261 a IN OUT UTL_NLA_ARRAY_FLT,
4262 lda IN POSITIVEN,
4263 wr IN OUT UTL_NLA_ARRAY_FLT,
4264 wi IN OUT UTL_NLA_ARRAY_FLT,
4265 vl IN OUT UTL_NLA_ARRAY_FLT,
4266 ldvl IN POSITIVEN,
4267 vr IN OUT UTL_NLA_ARRAY_FLT,
4268 ldvr IN POSITIVEN,
4269 info OUT INTEGER,
4270 pack IN flag DEFAULT 'C');
4271
4272 -- [> Singular Value Decomposition <]
4273
4274 --
4275 -- Purpose
4276 -- =======
4277 --
4278 -- LAPACK_GESVD computes the singular value decomposition (SVD) of a real
4279 -- M-by-N matrix A, optionally computing the left and/or right singular
4280 -- vectors. The SVD is written
4281 --
4282 -- A = U * SIGMA * transpose(V)
4283 --
4284 -- where SIGMA is an M-by-N matrix which is zero except for its
4285 -- min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
4286 -- V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA
4287 -- are the singular values of A; they are real and non-negative, and
4288 -- are returned in descending order. The first min(m,n) columns of
4289 -- U and V are the left and right singular vectors of A.
4290 --
4291 -- Note that the routine returns V**T, not V.
4292 --
4293 -- Arguments
4294 -- =========
4295 --
4296 -- JOBU (input) FLAG
4297 -- Specifies options for computing all or part of the matrix U:
4298 -- = 'A': all M columns of U are returned in array U:
4299 -- = 'S': the first min(m,n) columns of U (the left singular
4300 -- vectors) are returned in the array U;
4301 -- = 'O': the first min(m,n) columns of U (the left singular
4302 -- vectors) are overwritten on the array A;
4303 -- = 'N': no columns of U (no left singular vectors) are
4304 -- computed.
4305 --
4306 -- JOBVT (input) FLAG
4307 -- Specifies options for computing all or part of the matrix
4308 -- V**T:
4309 -- = 'A': all N rows of V**T are returned in the array VT;
4310 -- = 'S': the first min(m,n) rows of V**T (the right singular
4311 -- vectors) are returned in the array VT;
4312 -- = 'O': the first min(m,n) rows of V**T (the right singular
4313 -- vectors) are overwritten on the array A;
4314 -- = 'N': no rows of V**T (no right singular vectors) are
4315 -- computed.
4316 --
4317 -- JOBVT and JOBU cannot both be 'O'.
4318 --
4319 -- M (input) INTEGER
4320 -- The number of rows of the input matrix A. M >= 0.
4321 --
4322 -- N (input) INTEGER
4323 -- The number of columns of the input matrix A. N >= 0.
4324 --
4325 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA,N)
4326 -- On entry, the M-by-N matrix A.
4327 -- On exit,
4328 -- if JOBU = 'O', A is overwritten with the first min(m,n)
4329 -- columns of U (the left singular vectors,
4330 -- stored columnwise);
4331 -- if JOBVT = 'O', A is overwritten with the first min(m,n)
4332 -- rows of V**T (the right singular vectors,
4333 -- stored rowwise);
4334 -- if JOBU .ne. 'O' and JOBVT .ne. 'O', the contents of A
4335 -- are destroyed.
4336 --
4337 -- LDA (input) INTEGER
4338 -- The leading dimension of the array A. LDA >= max(1,M).
4339 --
4340 -- S (output) UTL_NLA_ARRAY_FLT/DBL, dimension (min(M,N))
4341 -- The singular values of A, sorted so that S(i) >= S(i+1).
4342 --
4343 -- U (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDU,UCOL)
4344 -- (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU = 'S'.
4345 -- If JOBU = 'A', U contains the M-by-M orthogonal matrix U;
4346 -- if JOBU = 'S', U contains the first min(m,n) columns of U
4350 -- LDU (input) INTEGER
4347 -- (the left singular vectors, stored columnwise);
4348 -- if JOBU = 'N' or 'O', U is not referenced.
4349 --
4351 -- The leading dimension of the array U. LDU >= 1; if
4352 -- JOBU = 'S' or 'A', LDU >= M.
4353 --
4354 -- VT (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDVT,N)
4355 -- If JOBVT = 'A', VT contains the N-by-N orthogonal matrix
4356 -- V**T;
4357 -- if JOBVT = 'S', VT contains the first min(m,n) rows of
4358 -- V**T (the right singular vectors, stored rowwise);
4359 -- if JOBVT = 'N' or 'O', VT is not referenced.
4360 --
4361 -- LDVT (input) INTEGER
4362 -- The leading dimension of the array VT. LDVT >= 1; if
4363 -- JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >= min(M,N).
4364 --
4365 -- INFO (output) INTEGER
4366 -- = 0: successful exit.
4367 -- < 0: if INFO = -i, the i-th argument had an illegal value.
4368 -- > 0: if SBDSQR did not converge, INFO specifies how many
4369 -- superdiagonals of an intermediate bidiagonal form B
4370 -- did not converge to zero. See the description of WORK
4371 -- above for details.
4372 --
4373 -- PACK (optional) FLAG
4374 -- The packing of the matricies:
4375 -- 'C': column-major (default)
4376 -- 'R': row-major
4377
4378 PROCEDURE lapack_gesvd(jobu IN flag,
4379 jobvt IN flag,
4380 m IN POSITIVEN,
4381 n IN POSITIVEN,
4382 a IN OUT utl_nla_array_dbl,
4383 lda IN POSITIVEN,
4384 s IN OUT utl_nla_array_dbl,
4385 u IN OUT utl_nla_array_dbl,
4386 ldu IN POSITIVEN,
4387 vt IN OUT utl_nla_array_dbl,
4388 ldvt IN POSITIVEN,
4389 info OUT integer,
4390 pack IN flag DEFAULT 'C');
4391
4392 PROCEDURE lapack_gesvd(jobu IN flag,
4393 jobvt IN flag,
4394 m IN POSITIVEN,
4395 n IN POSITIVEN,
4396 a IN OUT UTL_NLA_ARRAY_FLT,
4397 lda IN POSITIVEN,
4398 s IN OUT UTL_NLA_ARRAY_FLT,
4399 u IN OUT UTL_NLA_ARRAY_FLT,
4400 ldu IN POSITIVEN,
4401 vt IN OUT UTL_NLA_ARRAY_FLT,
4402 ldvt IN POSITIVEN,
4403 info OUT integer,
4404 pack IN flag DEFAULT 'C');
4405
4406 --
4407 -- Purpose
4408 -- =======
4409 --
4410 -- LAPACK_GESDD computes the singular value decomposition (SVD) of a real
4411 -- M-by-N matrix A, optionally computing the left and right singular
4412 -- vectors. If singular vectors are desired, it uses a
4413 -- divide-and-conquer algorithm.
4414 --
4415 -- The SVD is written
4416 --
4417 -- A = U * SIGMA * transpose(V)
4418 --
4419 -- where SIGMA is an M-by-N matrix which is zero except for its
4420 -- min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and
4421 -- V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA
4422 -- are the singular values of A; they are real and non-negative, and
4423 -- are returned in descending order. The first min(m,n) columns of
4424 -- U and V are the left and right singular vectors of A.
4425 --
4426 -- Note that the routine returns VT = V**T, not V.
4427 --
4428 -- The divide and conquer algorithm makes very mild assumptions about
4429 -- floating point arithmetic.
4430 --
4431 -- Arguments
4432 -- =========
4433 --
4434 -- JOBZ (input) FLAG
4435 -- Specifies options for computing all or part of the matrix U:
4436 -- = 'A': all M columns of U and all N rows of V**T are
4437 -- returned in the arrays U and VT;
4438 -- = 'S': the first min(M,N) columns of U and the first
4439 -- min(M,N) rows of V**T are returned in the arrays U
4440 -- and VT;
4441 -- = 'O': If M >= N, the first N columns of U are overwritten
4442 -- on the array A and all rows of V**T are returned in
4443 -- the array VT;
4444 -- otherwise, all columns of U are returned in the
4445 -- array U and the first M rows of V**T are overwritten
4446 -- in the array VT;
4447 -- = 'N': no columns of U or rows of V**T are computed.
4448 --
4449 -- M (input) INTEGER
4450 -- The number of rows of the input matrix A. M >= 0.
4451 --
4452 -- N (input) INTEGER
4453 -- The number of columns of the input matrix A. N >= 0.
4454 --
4455 -- A (input/output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDA,N)
4456 -- On entry, the M-by-N matrix A.
4457 -- On exit,
4458 -- if JOBZ = 'O', A is overwritten with the first N columns
4459 -- of U (the left singular vectors, stored
4460 -- columnwise) if M >= N;
4461 -- A is overwritten with the first M rows
4462 -- of V**T (the right singular vectors, stored
4463 -- rowwise) otherwise.
4464 -- if JOBZ .ne. 'O', the contents of A are destroyed.
4465 --
4466 -- LDA (input) INTEGER
4467 -- The leading dimension of the array A. LDA >= max(1,M).
4468 --
4469 -- S (output) UTL_NLA_ARRAY_FLT/DBL, dimension (min(M,N))
4470 -- The singular values of A, sorted so that S(i) >= S(i+1).
4471 --
4472 -- U (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDU,UCOL)
4473 -- UCOL = M if JOBZ = 'A' or JOBZ = 'O' and M < N;
4474 -- UCOL = min(M,N) if JOBZ = 'S'.
4475 -- If JOBZ = 'A' or JOBZ = 'O' and M < N, U contains the M-by-M
4476 -- orthogonal matrix U;
4477 -- if JOBZ = 'S', U contains the first min(M,N) columns of U
4478 -- (the left singular vectors, stored columnwise);
4479 -- if JOBZ = 'O' and M >= N, or JOBZ = 'N', U is not referenced.
4480 --
4481 -- LDU (input) INTEGER
4482 -- The leading dimension of the array U. LDU >= 1; if
4483 -- JOBZ = 'S' or 'A' or JOBZ = 'O' and M < N, LDU >= M.
4484 --
4485 -- VT (output) UTL_NLA_ARRAY_FLT/DBL, dimension (LDVT,N)
4486 -- If JOBZ = 'A' or JOBZ = 'O' and M >= N, VT contains the
4487 -- N-by-N orthogonal matrix V**T;
4488 -- if JOBZ = 'S', VT contains the first min(M,N) rows of
4489 -- V**T (the right singular vectors, stored rowwise);
4490 -- if JOBZ = 'O' and M < N, or JOBZ = 'N', VT is not referenced.
4491 --
4492 -- LDVT (input) INTEGER
4493 -- The leading dimension of the array VT. LDVT >= 1; if
4494 -- JOBZ = 'A' or JOBZ = 'O' and M >= N, LDVT >= N;
4495 -- if JOBZ = 'S', LDVT >= min(M,N).
4496 --
4497 -- INFO (output) INTEGER
4498 -- = 0: successful exit.
4499 -- < 0: if INFO = -i, the i-th argument had an illegal value.
4500 -- > 0: SBDSDC did not converge, updating process failed.
4501 --
4502 -- PACK (optional) FLAG
4503 -- The packing of the matricies:
4504 -- 'C': column-major (default)
4505 -- 'R': row-major
4506
4507 PROCEDURE lapack_gesdd(jobz IN flag,
4508 m IN POSITIVEN,
4509 n IN POSITIVEN,
4510 a IN OUT utl_nla_array_dbl,
4511 lda IN POSITIVEN,
4512 s IN OUT utl_nla_array_dbl,
4513 u IN OUT utl_nla_array_dbl,
4514 ldu IN POSITIVEN,
4515 vt IN OUT utl_nla_array_dbl,
4516 ldvt IN POSITIVEN,
4517 info OUT INTEGER,
4518 pack IN flag DEFAULT 'C');
4519
4520 PROCEDURE lapack_gesdd(jobz IN flag,
4521 m IN POSITIVEN,
4522 n IN POSITIVEN,
4523 a IN OUT UTL_NLA_ARRAY_FLT,
4524 lda IN POSITIVEN,
4525 s IN OUT UTL_NLA_ARRAY_FLT,
4526 u IN OUT UTL_NLA_ARRAY_FLT,
4527 ldu IN POSITIVEN,
4528 vt IN OUT UTL_NLA_ARRAY_FLT,
4529 ldvt IN POSITIVEN,
4530 info OUT INTEGER,
4531 pack IN flag DEFAULT 'C');
4532 END UTL_NLA;
[Home] [Help]