--- a/LibDBlas.def
+++ b/LibDBlas.def
@@ -53,7 +53,7 @@
   (*------------------------------------------------------------------------*)
   (* Hinweis:                                                               *)
   (* ========                                                               *)
-  (* Bei den BLAS-Routinen werden Vektoren (ARRAY OF FLOAT) nur als "FLOAT" *)
+  (* Bei den BLAS-Routinen werden Vektoren (ARRAY OF REAL8) nur als "REAL8" *)
   (* uebergeben. Dies entspricht der Benutzung innerhalb von Fortran-       *)
   (* Routinen. Die Adressen werden innehalb der Routinen dann als offene    *)
   (* Felder genutzt. Eine Ueberpruefung von Indizes kann so leider nicht    *)
@@ -65,12 +65,12 @@
 
   (* $Id: LibDBlas.def,v 1.7 2018/09/12 13:20:49 mriedl Exp mriedl $ *)
 
-FROM Deklera IMPORT FLOAT,CFLOAT; (* REAL & COMPLEX type *)
-             IMPORT LibDBlasM2; (* dgemv,dgemm,zgemm,dger *)
+FROM LibDBlasL1F77 IMPORT REAL8,COMPLEX16;
+                   IMPORT LibDBlasM2; (* dgemv,dgemm,zgemm,dger *)
 
 PROCEDURE dnrm2(    n    : INTEGER;
-                VAR X    : (* ARRAY OF *) FLOAT;
-                    IncX : INTEGER): FLOAT;
+                VAR X    : (* ARRAY OF *) REAL8;
+                    IncX : INTEGER): REAL8;
 
           (*----------------------------------------------------------------*)
           (* dnrm2 returns the euclidean norm of a vector via the function  *)
@@ -78,9 +78,9 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE dswap(    N    : CARDINAL;
-                VAR X    : (* ARRAY OF *) FLOAT;  
+                VAR X    : (* ARRAY OF *) REAL8;  
                     incX : INTEGER;  
-                VAR Y    : (* ARRAY OF *) FLOAT;
+                VAR Y    : (* ARRAY OF *) REAL8;
                     incY : INTEGER);
 
           (*----------------------------------------------------------------*)
@@ -89,9 +89,9 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE dcopy(    N    : INTEGER;
-                VAR X    : (* ARRAY OF *) FLOAT;
+                VAR X    : (* ARRAY OF *) REAL8;
                     IncX : INTEGER;
-                VAR Y    : (* ARRAY OF *) FLOAT;
+                VAR Y    : (* ARRAY OF *) REAL8;
                     IncY : INTEGER);
 
           (*----------------------------------------------------------------*)
@@ -102,21 +102,21 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE drot(    N    : INTEGER;  
-               VAR X    : (* ARRAY OF *) FLOAT;  
+               VAR X    : (* ARRAY OF *) REAL8;  
                    incX : INTEGER;
-               VAR Y    : (* ARRAY OF *) FLOAT;
+               VAR Y    : (* ARRAY OF *) REAL8;
                    incY : INTEGER; 
-                   c,s  : FLOAT);
+                   c,s  : REAL8);
 
           (*----------------------------------------------------------------*)
           (* Applies a plane rotation.                                      *)
           (* Jack Dongarra, linpack, 3/11/78.                               *)
           (*----------------------------------------------------------------*)
 
-PROCEDURE drotg(VAR da : FLOAT;  
-                VAR db : FLOAT;  
-                VAR c  : FLOAT;  
-                VAR s  : FLOAT);
+PROCEDURE drotg(VAR da : REAL8;  
+                VAR db : REAL8;  
+                VAR c  : REAL8;  
+                VAR s  : REAL8);
 
           (*----------------------------------------------------------------*)
           (* Construct a Givens plane rotation                              *)
@@ -124,8 +124,8 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE dscal(   n    : INTEGER; 
-                   da   : FLOAT;
-               VAR X    : (* ARRAY OF *) FLOAT; 
+                   da   : REAL8;
+               VAR X    : (* ARRAY OF *) REAL8; 
                    IncX : INTEGER);
 
           (*----------------------------------------------------------------*)
@@ -135,10 +135,10 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE daxpy(    n    : INTEGER;
-                    da   : FLOAT;
-                VAR X    : (* ARRAY OF *) FLOAT; 
+                    da   : REAL8;
+                VAR X    : (* ARRAY OF *) REAL8; 
                     IncX : INTEGER;
-                VAR Y    : (* ARRAY OF *) FLOAT; 
+                VAR Y    : (* ARRAY OF *) REAL8; 
                     IncY : INTEGER);
 
           (*----------------------------------------------------------------*)
@@ -148,10 +148,10 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE ddot(    N    : INTEGER;
-               VAR X    : (* ARRAY OF *) FLOAT;
+               VAR X    : (* ARRAY OF *) REAL8;
                    IncX : INTEGER;
-               VAR Y    : (* ARRAY OF *) FLOAT;
-                   IncY : INTEGER) : FLOAT;
+               VAR Y    : (* ARRAY OF *) REAL8;
+                   IncY : INTEGER) : REAL8;
 
           (*----------------------------------------------------------------*)
           (* Forms the dot product of two vectors. Uses unrolled loops for  *)
@@ -161,7 +161,7 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE idamax(    n    : INTEGER;
-                 VAR X    : (* ARRAY OF *) FLOAT; 
+                 VAR X    : (* ARRAY OF *) REAL8; 
                      IncX : INTEGER) : INTEGER;
 
           (*----------------------------------------------------------------*)
@@ -174,7 +174,7 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE idamin(    n    : INTEGER;
-                 VAR X    : (* ARRAY OF *) FLOAT; 
+                 VAR X    : (* ARRAY OF *) REAL8; 
                      IncX : INTEGER) : INTEGER;
 
           (*----------------------------------------------------------------*)
@@ -187,8 +187,8 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE dasum(    n        : CARDINAL;
-                VAR X        : (* ARRAY OF *) FLOAT;
-                    IncX     : CARDINAL) : FLOAT;
+                VAR X        : (* ARRAY OF *) REAL8;
+                    IncX     : CARDINAL) : REAL8;
 
           (*----------------------------------------------------------------*)
           (* Berechnet die Summe der Absolutwerte der im Feld X gespeich-   *)
@@ -198,13 +198,13 @@
 (*
  * PROCEDURE dgemv(    Trans  : CHAR;
  *                     M,N    : INTEGER;
- *                     Alpha  : FLOAT;
- *                 VAR A      : ARRAY OF ARRAY OF FLOAT;
+ *                     Alpha  : REAL8;
+ *                 VAR A      : ARRAY OF ARRAY OF REAL8;
  *                     LDA    : INTEGER;
- *                 VAR X      : ARRAY OF FLOAT;
+ *                 VAR X      : ARRAY OF REAL8;
  *                     IncX   : INTEGER;
- *                     Beta   : FLOAT;
- *                 VAR Y      : ARRAY OF FLOAT;
+ *                     Beta   : REAL8;
+ *                 VAR Y      : ARRAY OF REAL8;
  *                     IncY   : INTEGER);
  *)
 
@@ -279,13 +279,13 @@
 (*
  * PROCEDURE dgemm(    TransA,TransB : CHAR;
  *                     M,N,K         : INTEGER;
- *                     Alpha         : FLOAT;
- *                 VAR A             : ARRAY OF ARRAY OF FLOAT;
+ *                     Alpha         : REAL8;
+ *                 VAR A             : ARRAY OF ARRAY OF REAL8;
  *                     LDA           : INTEGER;
- *                 VAR B             : ARRAY OF ARRAY OF FLOAT;
+ *                 VAR B             : ARRAY OF ARRAY OF REAL8;
  *                     LDB           : INTEGER;
- *                     Beta          : FLOAT;
- *                 VAR C             : ARRAY OF ARRAY OF FLOAT;
+ *                     Beta          : REAL8;
+ *                 VAR C             : ARRAY OF ARRAY OF REAL8;
  *                     LDC           : INTEGER);
  *)
 
@@ -382,20 +382,30 @@
           (* (MatMatProd{NN|NT|TN,TT}) wenn nicht eine "schnelle" BLAS      *)
           (* Bibiliotek (z.B. OpenBlas, ATLAS) eingebunden wird             *)
           (*                                                                *)
-          (*  M : Anzahl der Zeilen der Matrix op(A) und der Matrix C       *)
-          (*  N : Anzahl der Spalten der Matrix op(B) und der Matrix C      *)
-          (*  K : Anzahl der Zeilen der Matrix op(A) und der Spalten        *)
-          (*      der Matrix op(B)                                          *)
+          (* TransA : Spezifiziert ob die Matrix A transponiert werden soll *)
+          (* TransB : Spezifiziert ob die Matrix B transponiert werden soll *)
+          (* M      : Anzahl der Zeilen der Matrix op(A) und der Matrix C   *)
+          (* N      : Anzahl der Spalten der Matrix op(B) und der Matrix C  *)
+          (* K      : Anzahl der Zeilen der Matrix op(A) und der Spalten    *)
+          (*          der Matrix op(B)                                      *)
+          (* Alpha  : Skalierungsfaktor fuer das Product der Matrizen A & B *)
+          (* A      : Matrix A                                              *)
+          (* lda    : ungenutzt                                             *)
+          (* B      : Matrix B                                              *)
+          (* ldb    : ungenutzt                                             *)
+          (* Beta   : Skalierungfaktor fuer die Matrix C                    *)
+          (* C      : Matrix C                                              *)
+          (* ldc    : ungenutzt                                             *)
           (*----------------------------------------------------------------*)
 
 (*
  * PROCEDURE dger(    m,n   : CARDINAL;
- *                    Alpha : FLOAT;
- *                VAR X     : ARRAY OF FLOAT;
+ *                    Alpha : REAL8;
+ *                VAR X     : ARRAY OF REAL8;
  *                    IncX  : CARDINAL;
- *                VAR Y     : ARRAY OF FLOAT;
+ *                VAR Y     : ARRAY OF REAL8;
  *                    IncY  : CARDINAL;
- *                VAR A     : ARRAY OF ARRAY OF FLOAT;
+ *                VAR A     : ARRAY OF ARRAY OF REAL8;
  *                    lda   : CARDINAL);
  *)
 
@@ -443,9 +453,9 @@
 (*============================= complexe procedures ========================*)
 
 PROCEDURE zswap( N       : CARDINAL;
-                VAR X    : (* ARRAY OF *) CFLOAT;
+                VAR X    : (* ARRAY OF *) COMPLEX16;
                     IncX : INTEGER;
-                VAR Y    : (* ARRAY OF *) CFLOAT;
+                VAR Y    : (* ARRAY OF *) COMPLEX16;
                     IncY : INTEGER);
 
           (*----------------------------------------------------------------*)
@@ -453,9 +463,9 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE zcopy(    N    : INTEGER;
-                VAR X    : (* ARRAY OF *) CFLOAT;
+                VAR X    : (* ARRAY OF *) COMPLEX16;
                     IncX : INTEGER;
-                VAR Y    : (* ARRAY OF *) CFLOAT;
+                VAR Y    : (* ARRAY OF *) COMPLEX16;
                     IncY : INTEGER);
 
           (*----------------------------------------------------------------*)
@@ -466,10 +476,10 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE zdotu(    N    : INTEGER;
-                VAR X    : (* ARRAY OF *) CFLOAT;
+                VAR X    : (* ARRAY OF *) COMPLEX16;
                     IncX : INTEGER;
-                VAR Y    : (* ARRAY OF *) CFLOAT;
-                    IncY : INTEGER) : CFLOAT;
+                VAR Y    : (* ARRAY OF *) COMPLEX16;
+                    IncY : INTEGER) : COMPLEX16;
 
           (*----------------------------------------------------------------*)
           (* Forms the dot product of two vectors X*Y                       *)
@@ -477,10 +487,10 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE zdotc(    N    : INTEGER;
-                VAR X    : (* ARRAY OF *) CFLOAT;
+                VAR X    : (* ARRAY OF *) COMPLEX16;
                     IncX : INTEGER;
-                VAR Y    : (* ARRAY OF *) CFLOAT;
-                    IncY : INTEGER) : CFLOAT;
+                VAR Y    : (* ARRAY OF *) COMPLEX16;
+                    IncY : INTEGER) : COMPLEX16;
 
           (*----------------------------------------------------------------*)
           (* Forms the dot product of two vectors conj(X)*Y                 *)
@@ -488,8 +498,8 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE dznrm2(    N    : INTEGER;
-                 VAR X    : (* ARRAY OF *) CFLOAT;
-                     IncX : INTEGER) : FLOAT;
+                 VAR X    : (* ARRAY OF *) COMPLEX16;
+                     IncX : INTEGER) : REAL8;
 
           (*----------------------------------------------------------------*)
           (* dznrm2 returns the euclidean norm of a vector so that          *)
@@ -497,8 +507,8 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE zscal(    n    : INTEGER;
-                    da   : CFLOAT;
-                VAR dx   : (* ARRAY OF *) CFLOAT;
+                    da   : COMPLEX16;
+                VAR dx   : (* ARRAY OF *) COMPLEX16;
                     IncX : INTEGER);
 
           (*----------------------------------------------------------------*)
@@ -506,10 +516,10 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE zaxpy(    n    : INTEGER;
-                    da   : CFLOAT;
-                VAR X    : (* ARRAY OF *) CFLOAT;
+                    za   : COMPLEX16;
+                VAR X    : (* ARRAY OF *) COMPLEX16;
                     IncX : INTEGER;
-                VAR Y    : (* ARRAY OF *) CFLOAT;
+                VAR Y    : (* ARRAY OF *) COMPLEX16;
                     IncY : INTEGER);
 
           (*----------------------------------------------------------------*)
@@ -517,11 +527,11 @@
           (*----------------------------------------------------------------*)
 
 PROCEDURE zdrot(    N    : INTEGER;
-                VAR X    : (* ARRAY OF *) CFLOAT;
+                VAR X    : (* ARRAY OF *) COMPLEX16;
                     IncX : INTEGER;
-                VAR Y    : (* ARRAY OF *) CFLOAT;
+                VAR Y    : (* ARRAY OF *) COMPLEX16;
                     IncY : INTEGER;
-                    c,s  : FLOAT);
+                    c,s  : REAL8);
 
           (*----------------------------------------------------------------*)
           (* Applies a plane rotation, where the cos and sin (c and s) are  *)
@@ -531,13 +541,13 @@
 (*
  * PROCEDURE zgemv(    Trans : CHAR; 
  *                     M,N   : INTEGER;
- *                     Alpha : CFLOAT;
- *                 VAR A     : ARRAY OF ARRAY OF CFLOAT;
+ *                     Alpha : COMPLEX16;
+ *                 VAR A     : ARRAY OF ARRAY OF COMPLEX16;
  *                     lda   : INTEGER;
- *                 VAR X     : ARRAY OF CFLOAT;
+ *                 VAR X     : ARRAY OF COMPLEX16;
  *                     IncX  : INTEGER;
- *                     Beta  : CFLOAT;
- *                 VAR Y     : ARRAY OF CFLOAT;
+ *                     Beta  : COMPLEX16;
+ *                 VAR Y     : ARRAY OF COMPLEX16;
  *                     IncY  : INTEGER);
  *)
 
@@ -606,13 +616,13 @@
 (*
  * PROCEDURE zgemm(    TransA,TransB : CHAR;
  *                     M,N,K         : INTEGER;
- *                     Alpha         : CFLOAT;
- *                 VAR A             : ARRAY OF ARRAY OF CFLOAT;
+ *                     Alpha         : COMPLEX16;
+ *                 VAR A             : ARRAY OF ARRAY OF COMPLEX16;
  *                     LDA           : INTEGER;
- *                 VAR B             : ARRAY OF ARRAY OF CFLOAT;
+ *                 VAR B             : ARRAY OF ARRAY OF COMPLEX16;
  *                     LDB           : INTEGER;
- *                     Beta          : CFLOAT;
- *                 VAR C             : ARRAY OF ARRAY OF CFLOAT;
+ *                     Beta          : COMPLEX16;
+ *                 VAR C             : ARRAY OF ARRAY OF COMPLEX16;
  *                     LDC           : INTEGER);
  *)