Menu
▾
▴
[Matlisp-commit] [matlisp-git]matlisp branch tensor updated. 2012-02-23-96-g8aff3fd
|
From: Akshay S. <ak...@us...> - 2012-06-28 09:14:25
|
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "matlisp".
The branch, tensor has been updated
via 8aff3fd16623c50df552430e3734fc65d11a55b1 (commit)
via 8df10fb5dce5cc4da3e196d0ae94494857a53f50 (commit)
from 82125cbf389c2f1bc43a5c661067400efcec64c3 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 8aff3fd16623c50df552430e3734fc65d11a55b1
Author: Akshay Srinivasan <aks...@gm...>
Date: Thu Jun 28 14:39:23 2012 +0530
Added basic copy-generation macros.
diff --git a/matlisp.asd b/matlisp.asd
index 1a5eecc..371e5a9 100644
--- a/matlisp.asd
+++ b/matlisp.asd
@@ -86,6 +86,8 @@
"foreign-functions")
:components ((:file "conditions")
(:file "standard-tensor")
+ (:file "loopy"
+ :depends-on ("standard-tensor"))
(:file "real-tensor"
:depends-on ("standard-tensor"))
(:file "complex-tensor"
diff --git a/packages.lisp b/packages.lisp
index cbe1052..ee8fbf4 100644
--- a/packages.lisp
+++ b/packages.lisp
@@ -161,7 +161,8 @@
#:slot-values
#:recursive-append #:unquote-args #:flatten
#:format-to-string #:string+
- #:linear-array-type
+ #:linear-array-type
+ #:seq-max #:seq-min
;;Macros
#:when-let #:if-let #:if-ret #:with-gensyms #:let-rec
#:mlet* #:make-array-allocator
diff --git a/src/blas.lisp b/src/blas.lisp
index 8f3e25b..3222da9 100644
--- a/src/blas.lisp
+++ b/src/blas.lisp
@@ -3,14 +3,14 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Copyright (c) 2000 The Regents of the University of California.
-;;; All rights reserved.
-;;;
+;;; All rights reserved.
+;;;
;;; Permission is hereby granted, without written agreement and without
;;; license or royalty fees, to use, copy, modify, and distribute this
;;; software and its documentation for any purpose, provided that the
;;; above copyright notice and the following two paragraphs appear in all
;;; copies of this software.
-;;;
+;;;
;;; IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
;;; FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
;;; ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
@@ -63,37 +63,37 @@
"
Syntax
======
-
+
(DAXPY n a x incx y incy)
Purpose
=======
Y <- A*X + Y
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
+ Number of elements of X,Y to be operated on.
+
A (input) DOUBLE-FLOAT
- X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- X(0),X(INCX), ... , X((N-1)*INCX)
+ X(0),X(INCX), ... , X((N-1)*INCX)
Y (input/output) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ INCY (input) FIXNUM
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(INCY), ... , Y((N-1)*INCY)
-"
+ Y(0),Y(INCY), ... , Y((N-1)*INCY)
+"
(n :integer :input)
(da :double-float :input)
(dx (* :double-float :inc head-x))
@@ -106,36 +106,36 @@
"
Syntax
======
-
+
(DCOPY n x incx y incy)
Purpose
=======
Y <- X
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
- X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ Number of elements of X,Y to be operated on.
+
+ X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- X(0),X(INCX), ... , X((N-1)*INCX)
+ X(0),X(INCX), ... , X((N-1)*INCX)
Y (input/output) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ INCY (input) FIXNUM
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(INCY), ... , Y((N-1)*INCY)
-"
+ Y(0),Y(INCY), ... , Y((N-1)*INCY)
+"
(n :integer :input)
(dx (* :double-float :inc head-x))
(incx :integer :input)
@@ -166,28 +166,28 @@
"
Syntax
======
-
+
(DSCAL n a x incx)
Purpose
=======
X <- A*X
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X to be operated on.
-
- X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
-
- X(0),X(INCX), ... , X((N-1)*INCX)
-"
+ Number of elements of X to be operated on.
+
+ X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
+
+ X(0),X(INCX), ... , X((N-1)*INCX)
+"
(n :integer :input)
(da :double-float :input)
(dx (* :double-float :inc head-x) :output)
@@ -198,36 +198,36 @@
"
Syntax
======
-
+
(DSWAP n x incx y incy)
Purpose
=======
Y <-> X
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
- X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ Number of elements of X,Y to be operated on.
+
+ X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- X(0),X(INCX), ... , X((N-1)*INCX)
+ X(0),X(INCX), ... , X((N-1)*INCX)
Y (input/output) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ INCY (input) FIXNUM
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(INCY), ... , Y((N-1)*INCY)
-"
+ Y(0),Y(INCY), ... , Y((N-1)*INCY)
+"
(n :integer :input)
(dx (* :double-float) :output)
(incx :integer :input)
@@ -239,37 +239,37 @@
"
Syntax
======
-
+
(ZAXPY n a x incx y incy)
Purpose
=======
Y <- A*X + Y
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
+ Number of elements of X,Y to be operated on.
+
A (input) (COMPLEX DOUBLE-FLOAT)
- X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+ X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
- Y (input/output) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ Y (input/output) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
-"
+ Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
+"
(n :integer :input)
(za :complex-double-float)
(zx (* :complex-double-float :inc head-x))
@@ -282,37 +282,37 @@
"
Syntax
======
-
+
(ZCOPY n x incx y incy)
Purpose
=======
Y <- X
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
+ Number of elements of X,Y to be operated on.
+
A (input) (COMPLEX DOUBLE-FLOAT)
- X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+ X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
- Y (input/output) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ Y (input/output) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
-"
+ Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
+"
(n :integer :input)
(zx (* :complex-double-float :inc head-x))
(incx :integer :input)
@@ -324,29 +324,29 @@
"
Syntax
======
-
+
(ZDSCAL n a x incx)
Purpose
=======
X <- A*X
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X to be operated on.
-
+ Number of elements of X to be operated on.
+
A (input) DOUBLE-FLOAT
- X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
-
- X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
-"
+ X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
+
+ X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+"
(n :integer :input)
(da :double-float :input)
(zx (* :complex-double-float :inc head-x) :output)
@@ -366,29 +366,29 @@
"
Syntax
======
-
+
(ZSCAL n a x incx)
Purpose
=======
X <- A*X
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X to be operated on.
-
+ Number of elements of X to be operated on.
+
A (input) (COMPLEX DOUBLE-FLOAT)
- X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
-
- X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
-"
+ X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
+
+ X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+"
(n :integer :input)
(za :complex-double-float)
(zx (* :complex-double-float :inc head-x) :output)
@@ -399,37 +399,37 @@
"
Syntax
======
-
+
(ZSWAP n x incx y incy)
Purpose
=======
Y <-> X
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
+ Number of elements of X,Y to be operated on.
+
A (input) (COMPLEX DOUBLE-FLOAT)
- X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+ X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
- Y (input/output) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ Y (input/output) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
-"
+ Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
+"
(n :integer :input)
(zx (* :complex-double-float) :output)
(incx :integer :input)
@@ -442,7 +442,7 @@
"
Syntax
======
-
+
(ZDOTU n x incx y incy)
Purpose
@@ -451,28 +451,28 @@
ZDOTU <- X^T Y
Complex precision inner product of X,Y.
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
- X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ Number of elements of X,Y to be operated on.
- X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+ X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- Y (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+
+ Y (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
+ Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
"
(n :integer :input)
(zx (* :complex-double-float) :input)
@@ -490,9 +490,10 @@
(incy :integer :input)
)
-(let ((result (make-array 2 :element-type 'double-float)))
- (defun zdotu (n zx incx zy incy &key (head-x 0) (head-y 0))
- (mzdotu result n zx incx zy incy :head-x head-x :head-y head-y)
+(defun zdotu (n zx incx zy incy &optional (head-x 0) (head-y 0))
+ (let ((result (make-array 2 :element-type 'double-float)))
+ (declare (type (simple-array double-float (2)) result))
+ (mzdotu result n zx incx zy incy head-x head-y)
(complex (aref result 0) (aref result 1))))
#-(and)
@@ -500,7 +501,7 @@
"
Syntax
======
-
+
(ZDOTC n x incx y incy)
Purpose
@@ -509,28 +510,28 @@
ZDOTC <- X^H Y
Complex precision inner product of X conjugate and Y.
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
- X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ Number of elements of X,Y to be operated on.
+
+ X (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+ X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
- Y (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
+ Y (input) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)) represented as (SIMPLE-ARRAY DOUBLE-FLOAT (*))
INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
+ Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
"
(n :integer :input)
(zx (* :complex-double-float) :input)
@@ -548,9 +549,11 @@
(incy :integer :input)
)
-(let ((result (make-array 2 :element-type 'double-float)))
- (defun zdotc (n zx incx zy incy &key (head-x 0) (head-y 0))
- (mzdotc result n zx incx zy incy :head-x head-x :head-y head-y)
+
+(defun zdotc (n zx incx zy incy &optional (head-x 0) (head-y 0))
+ (let ((result (make-array 2 :element-type 'double-float)))
+ (declare (type (simple-array double-float (*)) result))
+ (mzdotc result n zx incx zy incy head-x head-y)
(complex (aref result 0) (aref result 1))))
@@ -579,7 +582,7 @@
"
Syntax
======
-
+
(DDOT n x incx y incy)
Purpose
@@ -588,29 +591,29 @@
DDOT <- X^T Y
Double precision inner product of X,Y.
-
+
Arguments
=========
N (input) FIXNUM
- Number of elements of X,Y to be operated on.
-
+ Number of elements of X,Y to be operated on.
+
X (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
- INCX (input) FIXNUM
- Determines the position of the elements in X. Usually
- INCX is 1. If INCX is bigger than 1 then the elements
- considered in the operations are:
+ INCX (input) FIXNUM
+ Determines the position of the elements in X. Usually
+ INCX is 1. If INCX is bigger than 1 then the elements
+ considered in the operations are:
- X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
+ X(0),X(2*INCX), ... , X(2*(N-1)*INCX)
Y (input) (SIMPLE-ARRAY DOUBLE-FLOAT (*))
INCY (input) FIXNUM
- Determines the position of the elements in Y. Usually
- INCY is 1. If INCY is bigger than 1 then the elements
- considered in the operations are:
+ Determines the position of the elements in Y. Usually
+ INCY is 1. If INCY is bigger than 1 then the elements
+ considered in the operations are:
- Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
- "
+ Y(0),Y(2*INCY), ... , Y(2*(N-1)*INCY)
+ "
(n :integer :input)
(dx (* :double-float :inc head-x) :input)
(incx :integer :input)
@@ -630,95 +633,95 @@
"
Purpose
=======
-
+
DGEMV performs one of the matrix-vector operations
-
+
y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y,
-
+
where alpha and beta are scalars, x and y are vectors and A is an
m by n matrix.
-
+
Parameters
==========
-
+
TRANS - CHARACTER*1.
- On entry, TRANS specifies the operation to be performed as
- follows:
-
- TRANS = 'N' or 'n' y := alpha*A*x + beta*y.
-
- TRANS = 'T' or 't' y := alpha*A'*x + beta*y.
-
- TRANS = 'C' or 'c' y := alpha*A'*x + beta*y.
-
- Unchanged on exit.
-
+ On entry, TRANS specifies the operation to be performed as
+ follows:
+
+ TRANS = 'N' or 'n' y := alpha*A*x + beta*y.
+
+ TRANS = 'T' or 't' y := alpha*A'*x + beta*y.
+
+ TRANS = 'C' or 'c' y := alpha*A'*x + beta*y.
+
+ Unchanged on exit.
+
M - INTEGER.
- On entry, M specifies the number of rows of the matrix A.
- M must be at least zero.
- Unchanged on exit.
-
+ On entry, M specifies the number of rows of the matrix A.
+ M must be at least zero.
+ Unchanged on exit.
+
N - INTEGER.
- On entry, N specifies the number of columns of the matrix A.
- N must be at least zero.
- Unchanged on exit.
-
+ On entry, N specifies the number of columns of the matrix A.
+ N must be at least zero.
+ Unchanged on exit.
+
ALPHA - DOUBLE PRECISION.
- On entry, ALPHA specifies the scalar alpha.
- Unchanged on exit.
-
+ On entry, ALPHA specifies the scalar alpha.
+ Unchanged on exit.
+
A - DOUBLE PRECISION array of DIMENSION ( LDA, n ).
- Before entry, the leading m by n part of the array A must
- contain the matrix of coefficients.
- Unchanged on exit.
-
+ Before entry, the leading m by n part of the array A must
+ contain the matrix of coefficients.
+ Unchanged on exit.
+
LDA - INTEGER.
- On entry, LDA specifies the first dimension of A as declared
- in the calling (sub) program. LDA must be at least
- max( 1, m ).
- Unchanged on exit.
-
+ On entry, LDA specifies the first dimension of A as declared
+ in the calling (sub) program. LDA must be at least
+ max( 1, m ).
+ Unchanged on exit.
+
X - DOUBLE PRECISION array of DIMENSION at least
- ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
- and at least
- ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
- Before entry, the incremented array X must contain the
- vector x.
- Unchanged on exit.
-
+ ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
+ and at least
+ ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
+ Before entry, the incremented array X must contain the
+ vector x.
+ Unchanged on exit.
+
INCX - INTEGER.
- On entry, INCX specifies the increment for the elements of
- X. INCX must not be zero.
- Unchanged on exit.
-
+ On entry, INCX specifies the increment for the elements of
+ X. INCX must not be zero.
+ Unchanged on exit.
+
BETA - DOUBLE PRECISION.
- On entry, BETA specifies the scalar beta. When BETA is
- supplied as zero then Y need not be set on input.
- Unchanged on exit.
-
+ On entry, BETA specifies the scalar beta. When BETA is
+ supplied as zero then Y need not be set on input.
+ Unchanged on exit.
+
Y - DOUBLE PRECISION array of DIMENSION at least
- ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
- and at least
- ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
- Before entry with BETA non-zero, the incremented array Y
- must contain the vector y. On exit, Y is overwritten by the
- updated vector y.
-
+ ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
+ and at least
+ ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
+ Before entry with BETA non-zero, the incremented array Y
+ must contain the vector y. On exit, Y is overwritten by the
+ updated vector y.
+
INCY - INTEGER.
- On entry, INCY specifies the increment for the elements of
- Y. INCY must not be zero.
- Unchanged on exit.
-
-
+ On entry, INCY specifies the increment for the elements of
+ Y. INCY must not be zero.
+ Unchanged on exit.
+
+
Level 2 Blas routine.
-
+
-- Written on 22-October-1986.
Jack Dongarra, Argonne National Lab.
Jeremy Du Croz, Nag Central Office.
Sven Hammarling, Nag Central Office.
Richard Hanson, Sandia National Labs.
-
-
+
+
"
(trans :string :input)
(m :integer )
@@ -737,93 +740,93 @@
"
Purpose
=======
-
+
DSYMV performs the matrix-vector operation
-
+
y := alpha*A*x + beta*y,
-
+
where alpha and beta are scalars, x and y are n element vectors and
A is an n by n symmetric matrix.
-
+
Parameters
==========
-
+
UPLO - CHARACTER*1.
- On entry, UPLO specifies whether the upper or lower
- triangular part of the array A is to be referenced as
- follows:
-
- UPLO = 'U' or 'u' Only the upper triangular part of A
- is to be referenced.
-
- UPLO = 'L' or 'l' Only the lower triangular part of A
- is to be referenced.
-
- Unchanged on exit.
-
+ On entry, UPLO specifies whether the upper or lower
+ triangular part of the array A is to be referenced as
+ follows:
+
+ UPLO = 'U' or 'u' Only the upper triangular part of A
+ is to be referenced.
+
+ UPLO = 'L' or 'l' Only the lower triangular part of A
+ is to be referenced.
+
+ Unchanged on exit.
+
N - INTEGER.
- On entry, N specifies the order of the matrix A.
- N must be at least zero.
- Unchanged on exit.
-
+ On entry, N specifies the order of the matrix A.
+ N must be at least zero.
+ Unchanged on exit.
+
ALPHA - DOUBLE PRECISION.
- On entry, ALPHA specifies the scalar alpha.
- Unchanged on exit.
-
+ On entry, ALPHA specifies the scalar alpha.
+ Unchanged on exit.
+
A - DOUBLE PRECISION array of DIMENSION ( LDA, n ).
- Before entry with UPLO = 'U' or 'u', the leading n by n
- upper triangular part of the array A must contain the upper
- triangular part of the symmetric matrix and the strictly
- lower triangular part of A is not referenced.
- Before entry with UPLO = 'L' or 'l', the leading n by n
- lower triangular part of the array A must contain the lower
- triangular part of the symmetric matrix and the strictly
- upper triangular part of A is not referenced.
- Unchanged on exit.
-
+ Before entry with UPLO = 'U' or 'u', the leading n by n
+ upper triangular part of the array A must contain the upper
+ triangular part of the symmetric matrix and the strictly
+ lower triangular part of A is not referenced.
+ Before entry with UPLO = 'L' or 'l', the leading n by n
+ lower triangular part of the array A must contain the lower
+ triangular part of the symmetric matrix and the strictly
+ upper triangular part of A is not referenced.
+ Unchanged on exit.
+
LDA - INTEGER.
- On entry, LDA specifies the first dimension of A as declared
- in the calling (sub) program. LDA must be at least
- max( 1, n ).
- Unchanged on exit.
-
+ On entry, LDA specifies the first dimension of A as declared
+ in the calling (sub) program. LDA must be at least
+ max( 1, n ).
+ Unchanged on exit.
+
X - DOUBLE PRECISION array of dimension at least
- ( 1 + ( n - 1 )*abs( INCX ) ).
- Before entry, the incremented array X must contain the n
- element vector x.
- Unchanged on exit.
-
+ ( 1 + ( n - 1 )*abs( INCX ) ).
+ Before entry, the incremented array X must contain the n
+ element vector x.
+ Unchanged on exit.
+
INCX - INTEGER.
- On entry, INCX specifies the increment for the elements of
- X. INCX must not be zero.
- Unchanged on exit.
-
+ On entry, INCX specifies the increment for the elements of
+ X. INCX must not be zero.
+ Unchanged on exit.
+
BETA - DOUBLE PRECISION.
- On entry, BETA specifies the scalar beta. When BETA is
- supplied as zero then Y need not be set on input.
- Unchanged on exit.
-
+ On entry, BETA specifies the scalar beta. When BETA is
+ supplied as zero then Y need not be set on input.
+ Unchanged on exit.
+
Y - DOUBLE PRECISION array of dimension at least
- ( 1 + ( n - 1 )*abs( INCY ) ).
- Before entry, the incremented array Y must contain the n
- element vector y. On exit, Y is overwritten by the updated
- vector y.
-
+ ( 1 + ( n - 1 )*abs( INCY ) ).
+ Before entry, the incremented array Y must contain the n
+ element vector y. On exit, Y is overwritten by the updated
+ vector y.
+
INCY - INTEGER.
- On entry, INCY specifies the increment for the elements of
- Y. INCY must not be zero.
- Unchanged on exit.
-
-
+ On entry, INCY specifies the increment for the elements of
+ Y. INCY must not be zero.
+ Unchanged on exit.
+
+
Level 2 Blas routine.
-
+
-- Written on 22-October-1986.
Jack Dongarra, Argonne National Lab.
Jeremy Du Croz, Nag Central Office.
Sven Hammarling, Nag Central Office.
Richard Hanson, Sandia National Labs.
-
-
+
+
"
(uplo :string :input)
(n :integer )
@@ -841,95 +844,95 @@
"
Purpose
=======
-
+
DTRMV performs one of the matrix-vector operations
-
+
x := A*x, or x := A'*x,
-
+
where x is an n element vector and A is an n by n unit, or non-unit,
upper or lower triangular matrix.
-
+
Parameters
==========
-
+
UPLO - CHARACTER*1.
- On entry, UPLO specifies whether the matrix is an upper or
- lower triangular matrix as follows:
-
- UPLO = 'U' or 'u' A is an upper triangular matrix.
-
- UPLO = 'L' or 'l' A is a lower triangular matrix.
-
- Unchanged on exit.
-
+ On entry, UPLO specifies whether the matrix is an upper or
+ lower triangular matrix as follows:
+
+ UPLO = 'U' or 'u' A is an upper triangular matrix.
+
+ UPLO = 'L' or 'l' A is a lower triangular matrix.
+
+ Unchanged on exit.
+
TRANS - CHARACTER*1.
- On entry, TRANS specifies the operation to be performed as
- follows:
-
- TRANS = 'N' or 'n' x := A*x.
-
- TRANS = 'T' or 't' x := A'*x.
-
- TRANS = 'C' or 'c' x := A'*x.
-
- Unchanged on exit.
-
+ On entry, TRANS specifies the operation to be performed as
+ follows:
+
+ TRANS = 'N' or 'n' x := A*x.
+
+ TRANS = 'T' or 't' x := A'*x.
+
+ TRANS = 'C' or 'c' x := A'*x.
+
+ Unchanged on exit.
+
DIAG - CHARACTER*1.
- On entry, DIAG specifies whether or not A is unit
- triangular as follows:
-
- DIAG = 'U' or 'u' A is assumed to be unit triangular.
-
- DIAG = 'N' or 'n' A is not assumed to be unit
- triangular.
-
- Unchanged on exit.
-
+ On entry, DIAG specifies whether or not A is unit
+ triangular as follows:
+
+ DIAG = 'U' or 'u' A is assumed to be unit triangular.
+
+ DIAG = 'N' or 'n' A is not assumed to be unit
+ triangular.
+
+ Unchanged on exit.
+
N - INTEGER.
- On entry, N specifies the order of the matrix A.
- N must be at least zero.
- Unchanged on exit.
-
+ On entry, N specifies the order of the matrix A.
+ N must be at least zero.
+ Unchanged on exit.
+
A - DOUBLE PRECISION array of DIMENSION ( LDA, n ).
- Before entry with UPLO = 'U' or 'u', the leading n by n
- upper triangular part of the array A must contain the upper
- triangular matrix and the strictly lower triangular part of
- A is not referenced.
- Before entry with UPLO = 'L' or 'l', the leading n by n
- lower triangular part of the array A must contain the lower
- triangular matrix and the strictly upper triangular part of
- A is not referenced.
- Note that when DIAG = 'U' or 'u', the diagonal elements of
- A are not referenced either, but are assumed to be unity.
- Unchanged on exit.
-
+ Before entry with UPLO = 'U' or 'u', the leading n by n
+ upper triangular part of the array A must contain the upper
+ triangular matrix and the strictly lower triangular part of
+ A is not referenced.
+ Before entry with UPLO = 'L' or 'l', the leading n by n
+ lower triangular part of the array A must contain the lower
+ triangular matrix and the strictly upper triangular part of
+ A is not referenced.
+ Note that when DIAG = 'U' or 'u', the diagonal elements of
+ A are not referenced either, but are assumed to be unity.
+ Unchanged on exit.
+
LDA - INTEGER.
- On entry, LDA specifies the first dimension of A as declared
- in the calling (sub) program. LDA must be at least
- max( 1, n ).
- Unchanged on exit.
-
+ On entry, LDA specifies the first dimension of A as declared
+ in the calling (sub) program. LDA must be at least
+ max( 1, n ).
+ Unchanged on exit.
+
X - DOUBLE PRECISION array of dimension at least
- ( 1 + ( n - 1 )*abs( INCX ) ).
- Before entry, the incremented array X must contain the n
- element vector x. On exit, X is overwritten with the
- tranformed vector x.
-
+ ( 1 + ( n - 1 )*abs( INCX ) ).
+ Before entry, the incremented array X must contain the n
+ element vector x. On exit, X is overwritten with the
+ tranformed vector x.
+
INCX - INTEGER.
- On entry, INCX specifies the increment for the elements of
- X. INCX must not be zero.
- Unchanged on exit.
-
-
+ On entry, INCX specifies the increment for the elements of
+ X. INCX must not be zero.
+ Unchanged on exit.
+
+
Level 2 Blas routine.
-
+
-- Written on 22-October-1986.
Jack Dongarra, Argonne National Lab.
Jeremy Du Croz, Nag Central Office.
Sven Hammarling, Nag Central Office.
Richard Hanson, Sandia National Labs.
-
-
+
+
"
(uplo :string :input)
(trans :string :input)
@@ -945,98 +948,98 @@
"
Purpose
=======
-
+
DTRSV solves one of the systems of equations
-
+
A*x = b, or A'*x = b,
-
+
where b and x are n element vectors and A is an n by n unit, or
non-unit, upper or lower triangular matrix.
-
+
No test for singularity or near-singularity is included in this
routine. Such tests must be performed before calling this routine.
-
+
Parameters
==========
-
+
UPLO - CHARACTER*1.
- On entry, UPLO specifies whether the matrix is an upper or
- lower triangular matrix as follows:
-
- UPLO = 'U' or 'u' A is an upper triangular matrix.
-
- UPLO = 'L' or 'l' A is a lower triangular matrix.
-
- Unchanged on exit.
-
+ On entry, UPLO specifies whether the matrix is an upper or
+ lower triangular matrix as follows:
+
+ UPLO = 'U' or 'u' A is an upper triangular matrix.
+
+ UPLO = 'L' or 'l' A is a lower triangular matrix.
+
+ Unchanged on exit.
+
TRANS - CHARACTER*1.
- On entry, TRANS specifies the equations to be solved as
- follows:
-
- TRANS = 'N' or 'n' A*x = b.
-
- TRANS = 'T' or 't' A'*x = b.
-
- TRANS = 'C' or 'c' A'*x = b.
-
- Unchanged on exit.
-
+ On entry, TRANS specifies the equations to be solved as
+ follows:
+
+ TRANS = 'N' or 'n' A*x = b.
+
+ TRANS = 'T' or 't' A'*x = b.
+
+ TRANS = 'C' or 'c' A'*x = b.
+
+ Unchanged on exit.
+
DIAG - CHARACTER*1.
- On entry, DIAG specifies whether or not A is unit
- triangular as follows:
-
- DIAG = 'U' or 'u' A is assumed to be unit triangular.
-
- DIAG = 'N' or 'n' A is not assumed to be unit
- triangular.
-
- Unchanged on exit.
-
+ On entry, DIAG specifies whether or not A is unit
+ triangular as follows:
+
+ DIAG = 'U' or 'u' A is assumed to be unit triangular.
+
+ DIAG = 'N' or 'n' A is not assumed to be unit
+ triangular.
+
+ Unchanged on exit.
+
N - INTEGER.
- On entry, N specifies the order of the matrix A.
- N must be at least zero.
- Unchanged on exit.
-
+ On entry, N specifies the order of the matrix A.
+ N must be at least zero.
+ Unchanged on exit.
+
A - DOUBLE PRECISION array of DIMENSION ( LDA, n ).
- Before entry with UPLO = 'U' or 'u', the leading n by n
- upper triangular part of the array A must contain the upper
- triangular matrix and the strictly lower triangular part of
- A is not referenced.
- Before entry with UPLO = 'L' or 'l', the leading n by n
- lower triangular part of the array A must contain the lower
- triangular matrix and the strictly upper triangular part of
- A is not referenced.
- Note that when DIAG = 'U' or 'u', the diagonal elements of
- A are not referenced either, but are assumed to be unity.
- Unchanged on exit.
-
+ Before entry with UPLO = 'U' or 'u', the leading n by n
+ upper triangular part of the array A must contain the upper
+ triangular matrix and the strictly lower triangular part of
+ A is not referenced.
+ Before entry with UPLO = 'L' or 'l', the leading n by n
+ lower triangular part of the array A must contain the lower
+ triangular matrix and the strictly upper triangular part of
+ A is not referenced.
+ Note that when DIAG = 'U' or 'u', the diagonal elements of
+ A are not referenced either, but are assumed to be unity.
+ Unchanged on exit.
+
LDA - INTEGER.
- On entry, LDA specifies the first dimension of A as declared
- in the calling (sub) program. LDA must be at least
- max( 1, n ).
- Unchanged on exit.
-
+ On entry, LDA specifies the first dimension of A as declared
+ in the calling (sub) program. LDA must be at least
+ max( 1, n ).
+ Unchanged on exit.
+
X - DOUBLE PRECISION array of dimension at least
- ( 1 + ( n - 1 )*abs( INCX ) ).
- Before entry, the incremented array X must contain the n
- element right-hand side vector b. On exit, X is overwritten
- with the solution vector x.
-
+ ( 1 + ( n - 1 )*abs( INCX ) ).
+ Before entry, the incremented array X must contain the n
+ element right-hand side vector b. On exit, X is overwritten
+ with the solution vector x.
+
INCX - INTEGER.
- On entry, INCX specifies the increment for the elements of
- X. INCX must not be zero.
- Unchanged on exit.
-
-
+ On entry, INCX specifies the increment for the elements of
+ X. INCX must not be zero.
+ Unchanged on exit.
+
+
Level 2 Blas routine.
-
+
-- Written on 22-October-1986.
Jack Dongarra, Argonne National Lab.
Jeremy Du Croz, Nag Central Office.
Sven Hammarling, Nag Central Office.
Richard Hanson, Sandia National Labs.
-
-
+
+
"
(uplo :string :input)
(trans :string :input)
@@ -1052,74 +1055,74 @@
"
Purpose
=======
-
+
DGER performs the rank 1 operation
-
+
A := alpha*x*y' + A,
-
+
where alpha is a scalar, x is an m element vector, y is an n element
vector and A is an m by n matrix.
-
+
Parameters
==========
-
+
M - INTEGER.
- On entry, M specifies the number of rows of the matrix A.
- M must be at least zero.
- Unchanged on exit.
-
+ On entry, M specifies the number of rows of the matrix A.
+ M must be at least zero.
+ Unchanged on exit.
+
N - INTEGER.
- On entry, N specifies the number of columns of the matrix A.
- N must be at least zero.
- Unchanged on exit.
-
+ On entry, N specifies the number of columns of the matrix A.
+ N must be at least zero.
+ Unchanged on exit.
+
ALPHA - DOUBLE PRECISION.
- On entry, ALPHA specifies the scalar alpha.
- Unchanged on exit.
-
+ On entry, ALPHA specifies the scalar alpha.
+ Unchanged on exit.
+
X - DOUBLE PRECISION array of dimension at least
- ( 1 + ( m - 1 )*abs( INCX ) ).
- Before entry, the incremented array X must contain the m
- element vector x.
- Unchanged on exit.
-
+ ( 1 + ( m - 1 )*abs( INCX ) ).
+ Before entry, the incremented array X must contain the m
+ element vector x.
+ Unchanged on exit.
+
INCX - INTEGER.
- On entry, INCX specifies the increment for the elements of
- X. INCX must not be zero.
- Unchanged on exit.
-
+ On entry, INCX specifies the increment for the elements of
+ X. INCX must not be zero.
+ Unchanged on exit.
+
Y - DOUBLE PRECISION array of dimension at least
- ( 1 + ( n - 1 )*abs( INCY ) ).
- Before entry, the incremented array Y must contain the n
- element vector y.
- Unchanged on exit.
-
+ ( 1 + ( n - 1 )*abs( INCY ) ).
+ Before entry, the incremented array Y must contain the n
+ element vector y.
+ Unchanged on exit.
+
INCY - INTEGER.
- On entry, INCY specifies the increment for the elements of
- Y. INCY must not be zero.
- Unchanged on exit.
-
+ On entry, INCY specifies the increment for the elements of
+ Y. INCY must not be zero.
+ Unchanged on exit.
+
A - DOUBLE PRECISION array of DIMENSION ( LDA, n ).
- Before entry, the leading m by n part of the array A must
- contain the matrix of coefficients. On exit, A is
- overwritten by the updated matrix.
-
+ Before entry, the leading m by n part of the array A must
+ contain the matrix of coefficients. On exit, A is
+ overwritten by the updated matrix.
+
LDA - INTEGER.
- On entry, LDA specifies the first dimension of A as declared
- in the calling (sub) program. LDA must be at least
- max( 1, m ).
- Unchanged on exit.
-
-
+ On entry, LDA specifies the first dimension of A as declared
+ in the calling (sub) program. LDA must be at least
+ max( 1, m ).
+ Unchanged on exit.
+
+
Level 2 Blas routine.
-
+
-- Written on 22-October-1986.
Jack Dongarra, Argonne National Lab.
Jeremy Du Croz, Nag Central Office.
Sven Hammarling, Nag Central Office.
Richard Hanson, Sandia National Labs.
-
-
+
+
"
(m :integer )
(n :integer )
@@ -1136,80 +1139,80 @@
"
Purpose
=======
-
+
DSYR performs the symmetric rank 1 operation
-
+
A := alpha*x*x' + A,
-
+
where alpha is a real scalar, x is an n element vector and A is an
n by n symmetric matrix.
-
+
Parameters
==========
-
+
UPLO - CHARACTER*1.
- On entry, UPLO specifies whether the upper or lower
- triangular part of the array A is to be referenced as
- follows:
-
- UPLO = 'U' or 'u' Only the upper triangular part of A
- is to be referenced.
-
- UPLO = 'L' or 'l' Only the lower triangular part of A
- is to be referenced.
-
- Unchanged on exit.
-
+ On entry, UPLO specifies whether the upper or lower
+ triangular part of the array A is to be referenced as
+ follows:
+
+ UPLO = 'U' or 'u' Only the upper triangular part of A
+ is to be referenced.
+
+ UPLO = 'L' or 'l' Only the lower triangular part of A
+ is to be referenced.
+
+ Unchanged on exit.
+
N - INTEGER.
- On entry, N specifies the order of the matrix A.
- N must be at least zero.
- Unchanged on exit.
-
+ On entry, N specifies the order of the matrix A.
+ N must be at least zero.
+ Unchanged on exit.
+
ALPHA - DOUBLE PRECISION.
- On entry, ALPHA specifies the scalar alpha.
- Unchanged on exit.
-
+ On entry, ALPHA specifies the scalar alpha.
+ Unchanged on exit.
+
X - DOUBLE PRECISION array of dimension at least
- ( 1 + ( n - 1 )*abs( INCX ) ).
- Before entry, the incremented array X must contain the n
- element vector x.
- Unchanged on exit.
-
+ ( 1 + ( n - 1 )*abs( INCX ) ).
+ Before entry, the incremented array X must contain the n
+ element vector x.
+ Unchanged on exit.
+
INCX - INTEGER.
- On entry, INCX specifies the increment for the elements of
- X. INCX must not be zero.
- Unchanged on exit.
-
+ On entry, INCX specifies the increment for the elements of
+ X. INCX must not be zero.
+ Unchanged on exit.
+
A - DOUBLE PRECISION array of DIMENSION ( LDA, n ).
- Before entry with UPLO = 'U' or 'u', the leading n by n
- upper triangular part of the array A must contain the upper
- triangular part of the symmetric matrix and the strictly
- lower triangular part of A is not referenced. On exit, the
- upper triangular part of the array A is overwritten by the
- upper triangular part of the updated matrix.
- Before entry with UPLO = 'L' or 'l', the leading n by n
- lower triangular part of the array A must contain the lower
- triangular part of the symmetric matrix and the strictly
- upper triangular part of A is not referenced. On exit, the
- lower triangular part of the array A is overwritten by the
- lower triangular part of the updated matrix.
-
+ Before entry with UPLO = 'U' or 'u', the leading n by n
+ upper triangular part of the array A must contain the upper
+ triangular part of the symmetric matrix and the strictly
+ lower triangular part of A is not referenced. On exit, the
+ upper triangular part of the array A is overwritten by the
+ upper triangular part of the updated matrix.
+ Before entry with UPLO = 'L' or 'l', the leading n by n
+ lower triangular part of the array A must contain the lower
+ triangular part of the symmetric matrix and the strictly
+ upper triangular part of A is not referenced. On exit, the
+ lower triangular part of the array A is overwritten by the
+ lower triangular part of the updated matrix.
+
LDA - INTEGER.
- On entry, LDA specifies the first dimension of A as declared
- in the calling (sub) program. LDA must be at least
- max( 1, n ).
- Unchanged on exit.
-
-
+ On entry, LDA specifies the first dimension of A as declared
+ in the calling (sub) program. LDA must be at least
+ max( 1, n ).
+ Unchanged on exit.
+
+
Level 2 Blas routine.
-
+
-- Written on 22-October-1986.
Jack Dongarra, Argonne National Lab.
Jeremy Du Croz, Nag Central Office.
Sven Hammarling, Nag Central Office.
Richard Hanson, Sandia National Labs.
-
-
+
+
"
(uplo :string :input)
(n :integer )
@@ -1224,91 +1227,91 @@
"
Purpose
=======
-
+
DSYR2 performs the symmetric rank 2 operation
-
+
A := alpha*x*y' + alpha*y*x' + A,
-
+
where alpha is a scalar, x and y are n element vectors and A is an n
by n symmetric matrix.
-
+
Parameters
==========
-
+
UPLO - CHARACTER*1.
- On entry, UPLO specifies whether the upper or lower
- triangular part of the array A is to be referenced as
- follows:
-
- UPLO = 'U' or 'u' Only the upper triangular part of A
- is to be referenced.
-
- UPLO = 'L' or 'l' Only the lower triangular part of A
- is to be referenced.
-
- Unchanged on exit.
-
+ On entry, UPLO specifies whether the upper or lower
+ triangular part of the array A is to be referenced as
+ follows:
+
+ UPLO = 'U' or 'u' Only the upper triangular part of A
+ is to be referenced.
+
+ UPLO = 'L' or 'l' Only the lower triangular part of A
+ is to be referenced.
+
+ Unchanged on exit.
+
N - INTEGER.
- On entry, N specifies the order of the matrix A.
- N must be at least zero.
- Unchanged on exit.
-
+ On entry, N specifies the order of the matrix A.
+ N must be at least zero.
+ Unchanged on exit.
+
ALPHA - DOUBLE PRECISION.
- On entry, ALPHA specifies the scalar alpha.
- Unchanged on exit.
-
+ On entry, ALPHA specifies the scalar alpha.
+ Unchanged on exit.
+
X - DOUBLE PRECISION array of dimension at least
- ( 1 + ( n - 1 )*abs( INCX ) ).
- Before entry, the incremented array X must contain the n
- element vector x.
- Unchanged on exit.
-
+ ( 1 + ( n - 1 )*abs( INCX ) ).
+ Before entry, the incremented array X must contain the n
+ element vector x.
+ Unchanged on exit.
+
INCX - INTEGER.
- On entry, INCX specifies the increment for the elements of
- X. INCX must not be zero.
- Unchanged on exit.
-
+ On entry, INCX specifies the increment for the elements of
+ X. INCX must not be zero.
+ Unchanged on exit.
+
Y - DOUBLE PRECISION array of dimension at least
- ( 1 + ( n - 1 )*abs( INCY ) ).
- Before entry, the incremented array Y must contain the n
- element vector y.
- Unchanged on exit.
-
+ ( 1 + ( n - 1 )*abs( INCY ) ).
+ Before entry, the incremented array Y must contain the n
+ element vector y.
+ Unchanged on exit.
+
INCY - INTEGER.
- On entry, INCY specifies the increment for the elements of
- Y. INCY must not be zero.
- Unchanged on exit.
-
+ On entry, INCY specifies the increment for the elements of
+ Y. INCY must not be zero.
+ Unchanged on exit.
+
A - DOUBLE PRECISION array of DIMENSION ( LDA, n ).
- Before entry with UPLO = 'U' or 'u', the leading n by n
- upper triangular part of the array A must contain the upper
- triangular part of the symmetric matrix and the strictly
- lower triangular part of A is not referenced. On exit, the
- upper triangular part of the array A is overwritten by the
- upper triangular part of the updated matrix.
- Before entry with UPLO = 'L' or 'l', the leading n by n
- lower triangular part of the array A must contain the lower
- triangular part of the symmetric matrix and the strictly
- upper triangular part of A is not referenced. On exit, the
- lower triangular part of the array A is overwritten by the
- lower triangular part of the updated matrix.
-
+ Before entry with UPLO = 'U' or 'u', the leading n by n
+ upper triangular part of the array A must contain the upper
+ triangular part of the symmetric matrix and the strictly
+ lower triangular part of A is not referenced. On exit, the
+ upper triangular part of the array A is overwritten by the
+ upper triangular part of the updated matrix.
+ Before entry with UPLO = 'L' or 'l', the leading n by n
+ lower triangular part of the array A must contain the lower
+ triangular part of the symmetric matrix and the strictly
+ upper triangular part of A is not referenced. On exit, the
+ lower triangular part of the array A is overwritten by the
+ lower triangular part of the updated matrix.
+
LDA - INTEGER.
- On entry, LDA specifies the first dimension of A as declared
- in the calling (sub) program. LDA must be at least
- max( 1, n ).
- Unchanged on exit.
-
-
+ On entry, LDA specifies the first dimension of A as declared
+ in the calling (sub) program. LDA must be at least
+ max( 1, n ).
+ Unchanged on exit.
+
+
Level 2 Blas routine.
-
+
-- Written on 22-October-1986.
Jack Dongarra, Argonne National Lab.
Jeremy Du Croz, Nag Central Office.
Sven Hammarling, Nag Central Office.
Richard Hanson, Sandia National Labs.
-
-
+
+
"
(uplo :string :input)
(n :integer )
@@ -1325,124 +1328,124 @@
"
Purpose
=======
-
+
DGEMM performs one of the matrix-matrix operations
-
+
C := alpha*op( A )*op( B ) + beta*C,
-
+
where op( X ) is one of
-
+
op( X ) = X or op( X ) = X',
-
+
alpha and beta are scalars, and A, B and C are matrices, with op( A )
an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
-
+
Parameters
==========
-
+
TRANSA - CHARACTER*1.
- On entry, TRANSA specifies the form of op( A ) to be used in
- the matrix multiplication as follows:
-
- TRANSA = 'N' or 'n', op( A ) = A.
-
- TRANSA = 'T' or 't', op( A ) = A'.
-
- TRANSA = 'C' or 'c', op( A ) = A'.
-
- Unchanged on exit.
-
+ On entry, TRANSA specifies the form of op( A ) to be used in
+ the matrix multiplication as follows:
+
+ TRANSA = 'N' or 'n', op( A ) = A.
+
+ TRANSA = 'T' or 't', op( A ) = A'.
+
+ TRANSA = 'C' or 'c', op( A ) = A'.
+
+ Unchanged on exit.
+
TRANSB - CHARACTER*1.
- On entry, TRANSB specifies the form of op( B ) to be used in
- the matrix multiplication as follows:
-
- TRANSB = 'N' or 'n', op( B ) = B.
-
- TRANSB = 'T' or 't', op( B ) = B'.
-
- TRANSB = 'C' or 'c', op( B ) = B'.
-
- Unchanged on exit.
-
+ On entry, TRANSB specifies the form of op( B ) to be used in
+ the matrix multiplication as follows:
+
+ TRANSB = 'N' or 'n', op( B ) = B.
+
+ TRANSB = 'T' or 't', op( B ) = B'.
+
+ TRANSB = 'C' or 'c', op( B ) = B'.
+
+ Unchanged on exit.
+
M - INTEGER.
- On entry, M specifies the number of rows of the matrix
- op( A ) and of the matrix C. M must be at least zero.
- Unchanged on exit.
-
+ On entry, M specifies the number of rows of the matrix
+ op( A ) and of the matrix C. M must be at least zero.
+ Unchanged on exit.
+
N - INTEGER.
- On entry, N specifies the number of columns of the matrix
- op( B ) and the number of columns of the matrix C. N must be
- at least zero.
- Unchanged on exit.
-
+ On entry, N specifies the number of columns of the matrix
+ op( B ) and the number of columns of the matrix C. N must be
+ at least zero.
+ Unchanged on exit.
+
K - INTEGER.
- On entry, K specifies the number of columns of the matrix
- op( A ) and the number of rows of the matrix op( B ). K must
- be at least zero.
- Unchanged on exit.
-
+ On entry, K specifies the number of columns of the matrix
+ op( A ) and the number of rows of the matrix op( B ). K must
+ be at least zero.
+ Unchanged on exit.
+
ALPHA - DOUBLE PRECISION.
- On entry, ALPHA specifies the scalar alpha.
- Unchanged on exit.
-
+ On entry, ALPHA specifies the scalar alpha.
+ Unchanged on exit.
+
A - DOUBLE PRECISION array of DIMENSION ( LDA, ka ), where ka is
- k when TRANSA = 'N' or 'n', and is m otherwise.
- Before entry with TRANSA = 'N' or 'n', the leading m by k
- part of the array A must contain the matrix A, otherwise
- the leading k by m part of the array A must contain the
- matrix A.
- Unchanged on exit.
-
+ k when TRANSA = 'N' or 'n', and is m otherwise.
+ Before entry with TRANSA = 'N' or 'n', the leading m by k
+ part of the array A must contain the matrix A, otherwise
+ the leading k by m part of the array A must contain the
+ matrix A.
+ Unchanged on exit.
+
LDA - INTEGER.
- On entry, LDA specifies the first dimension of A as declared
- in the calling (sub) program. When TRANSA = 'N' or 'n' then
- LDA must be at least max( 1, m ), otherwise LDA must be at
- least max( 1, k ).
- Unchanged on exit.
-
+ On entry, LDA specifies the first dimension of A as declared
+ in the calling (sub) program. When TRANSA = 'N' or 'n' then
+ LDA must be at least max( 1, m ), otherwise LDA must be at
+ least max( 1, k ).
+ Unchanged on exit.
+
B - DOUBLE PRECISION array of DIMENSION ( LDB, kb ), where kb is
- n when TRANSB = 'N' or 'n', and is k otherwise.
- Before entry with TRANSB = 'N' or 'n', the leading k by n
- part of the array B must contain the matrix B, otherwise
- the leading n by k part of the array B must contain the
- matrix B.
- Unchanged on exit.
-
+ n when TRANSB = 'N' or 'n', and is k otherwise.
+ Before entry with TRANSB = 'N' or 'n', the leading k by n
+ part of the array B must contain the matrix B, otherwise
+ the leading n by k part of the array B must contain the
+ matrix B.
+ Unchanged on exit.
+
LDB - INTEGER.
- On entry, LDB specifies the first dimension of B as declared
- in the calling (sub) program. When TRANSB = 'N' or 'n' then
- LDB must be at l...
[truncated message content] |
