CBLAS/examples/cblas_ex2
# LAPACK testing
-TESTING/x*
+TESTING/LIN/xlintst*
+TESTING/EIG/xeigtst*
TESTING/*.out
TESTING/*.txt
--- /dev/null
+include ../make.inc
+
+all: blas
+
+blas:
+ $(MAKE) -C SRC
+
+blas_testing: blas
+ $(MAKE) -C TESTING run
+
+clean:
+ $(MAKE) -C SRC clean
+ $(MAKE) -C TESTING clean
+cleanobj:
+ $(MAKE) -C SRC cleanobj
+ $(MAKE) -C TESTING cleanobj
+cleanlib:
+ $(MAKE) -C SRC cleanlib
+cleanexe:
+ $(MAKE) -C TESTING cleanexe
+cleantest:
+ $(MAKE) -C TESTING cleantest
# top-level make.inc
#
# To remove the object files after the library is created, enter
-# make clean
+# make cleanobj
# To force the source files to be recompiled, enter, for example,
# make single FRC=FRC
#
$(ZBLAS2) $(ZBLAS3) $(ALLBLAS)
$(BLASLIB): $(ALLOBJ)
- $(ARCH) $(ARCHFLAGS) $@ $(ALLOBJ)
+ $(ARCH) $(ARCHFLAGS) $@ $^
$(RANLIB) $@
single: $(SBLAS1) $(ALLBLAS) $(SBLAS2) $(SBLAS3)
- $(ARCH) $(ARCHFLAGS) $(BLASLIB) $(SBLAS1) $(ALLBLAS) \
- $(SBLAS2) $(SBLAS3)
+ $(ARCH) $(ARCHFLAGS) $(BLASLIB) $^
$(RANLIB) $(BLASLIB)
double: $(DBLAS1) $(ALLBLAS) $(DBLAS2) $(DBLAS3)
- $(ARCH) $(ARCHFLAGS) $(BLASLIB) $(DBLAS1) $(ALLBLAS) \
- $(DBLAS2) $(DBLAS3)
+ $(ARCH) $(ARCHFLAGS) $(BLASLIB) $^
$(RANLIB) $(BLASLIB)
complex: $(CBLAS1) $(CB1AUX) $(ALLBLAS) $(CBLAS2) $(CBLAS3)
- $(ARCH) $(ARCHFLAGS) $(BLASLIB) $(CBLAS1) $(CB1AUX) \
- $(ALLBLAS) $(CBLAS2) $(CBLAS3)
+ $(ARCH) $(ARCHFLAGS) $(BLASLIB) $^
$(RANLIB) $(BLASLIB)
complex16: $(ZBLAS1) $(ZB1AUX) $(ALLBLAS) $(ZBLAS2) $(ZBLAS3)
- $(ARCH) $(ARCHFLAGS) $(BLASLIB) $(ZBLAS1) $(ZB1AUX) \
- $(ALLBLAS) $(ZBLAS2) $(ZBLAS3)
+ $(ARCH) $(ARCHFLAGS) $(BLASLIB) $^
$(RANLIB) $(BLASLIB)
FRC:
@FRC=$(FRC)
-clean:
+clean: cleanobj cleanlib
+cleanobj:
rm -f *.o
+cleanlib:
+ #rm -f $(BLASLIB) # May point to a system lib, e.g. -lblas
.f.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
complex: xblat1c xblat2c xblat3c
complex16: xblat1z xblat2z xblat3z
-xblat1s: sblat1.o
- $(LOADER) $(LOADOPTS) -o $@ sblat1.o $(BLASLIB)
-xblat1d: dblat1.o
- $(LOADER) $(LOADOPTS) -o $@ dblat1.o $(BLASLIB)
-xblat1c: cblat1.o
- $(LOADER) $(LOADOPTS) -o $@ cblat1.o $(BLASLIB)
-xblat1z: zblat1.o
- $(LOADER) $(LOADOPTS) -o $@ zblat1.o $(BLASLIB)
+xblat1s: sblat1.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat1d: dblat1.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat1c: cblat1.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat1z: zblat1.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-xblat2s: sblat2.o
- $(LOADER) $(LOADOPTS) -o $@ sblat2.o $(BLASLIB)
-xblat2d: dblat2.o
- $(LOADER) $(LOADOPTS) -o $@ dblat2.o $(BLASLIB)
-xblat2c: cblat2.o
- $(LOADER) $(LOADOPTS) -o $@ cblat2.o $(BLASLIB)
-xblat2z: zblat2.o
- $(LOADER) $(LOADOPTS) -o $@ zblat2.o $(BLASLIB)
+xblat2s: sblat2.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat2d: dblat2.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat2c: cblat2.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat2z: zblat2.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-xblat3s: sblat3.o
- $(LOADER) $(LOADOPTS) -o $@ sblat3.o $(BLASLIB)
-xblat3d: dblat3.o
- $(LOADER) $(LOADOPTS) -o $@ dblat3.o $(BLASLIB)
-xblat3c: cblat3.o
- $(LOADER) $(LOADOPTS) -o $@ cblat3.o $(BLASLIB)
-xblat3z: zblat3.o
- $(LOADER) $(LOADOPTS) -o $@ zblat3.o $(BLASLIB)
+xblat3s: sblat3.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat3d: dblat3.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat3c: cblat3.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xblat3z: zblat3.o $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
run: all
./xblat1s > sblat1.out
./xblat3c < cblat3.in
./xblat3z < zblat3.in
-clean:
- rm -f *.o xblat* *.out
+clean: cleanobj cleanexe cleantest
+cleanobj:
+ rm -f *.o
+cleanexe:
+ rm -f xblat*
+cleantest:
+ rm -f *.out core
.f.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
include ../make.inc
-all:
- cd include && cp cblas_mangling_with_flags.h.in cblas_mangling.h
- cd src && $(MAKE) all
+all: cblas
+cblas: include/cblas_mangling.h
+ $(MAKE) -C src
-clean: cleanlib
+include/cblas_mangling.h: include/cblas_mangling_with_flags.h.in
+ cp $< $@
-cleanlib:
- cd src && $(MAKE) clean
-
-cleanexe:
- cd testing && $(MAKE) cleanexe
-
-cleanall: clean cleanexe
- cd src && $(MAKE) cleanall
- cd examples && $(MAKE) cleanall
+cblas_testing: cblas
+ $(MAKE) -C testing run
-cblas_testing:
- cd testing && $(MAKE) all
+cblas_example: cblas
+ $(MAKE) -C examples
-runtst:
- cd testing && $(MAKE) run
-
-example: all
- cd examples && $(MAKE) all
+clean:
+ $(MAKE) -C src clean
+ $(MAKE) -C testing clean
+ $(MAKE) -C examples clean
+cleanobj:
+ $(MAKE) -C src cleanobj
+ $(MAKE) -C testing cleanobj
+ $(MAKE) -C examples cleanobj
+cleanlib:
+ $(MAKE) -C src cleanlib
+cleanexe:
+ $(MAKE) -C testing cleanexe
+ $(MAKE) -C examples cleanexe
+cleantest:
+ $(MAKE) -C testing cleantest
all: cblas_ex1 cblas_ex2
-cblas_ex1: cblas_example1.o
- $(LOADER) $(LOADOPTS) -o $@ cblas_example1.o $(CBLASLIB) $(BLASLIB)
-cblas_ex2: cblas_example2.o
- $(LOADER) $(LOADOPTS) -o $@ cblas_example2.o $(CBLASLIB) $(BLASLIB)
+cblas_ex1: cblas_example1.o $(CBLASLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+cblas_ex2: cblas_example2.o $(CBLASLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-cleanall:
- rm -f *.o cblas_ex1 cblas_ex2
+clean: cleanobj cleanexe
+cleanobj:
+ rm -f *.o
+cleanexe:
+ rm -f cblas_ex1 cblas_ex2
.c.o:
$(CC) $(CFLAGS) -I../include -c -o $@ $<
# Single precision real
slib1: $(slev1) $(sclev1)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(slev1) $(sclev1)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Double precision real
dlib1: $(dlev1)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(dlev1)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Single precision complex
clib1: $(clev1) $(sclev1)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(clev1) $(sclev1)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Double precision complex
zlib1: $(zlev1)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(zlev1)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
#
# Single precision real
slib2: $(slev2) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(slev2) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Double precision real
dlib2: $(dlev2) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(dlev2) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Single precision complex
clib2: $(clev2) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(clev2) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Double precision complex
zlib2: $(zlev2) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(zlev2) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
#
# Single precision real
slib3: $(slev3) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(slev3) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Double precision real
dlib3: $(dlev3) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(dlev3) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Single precision complex
clib3: $(clev3) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(clev3) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# Double precision complex
zlib3: $(zlev3) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(zlev3) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# All level 1
all1: $(alev1)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(alev1)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# All level 2
all2: $(alev2) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(alev2) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# All level 3
all3: $(alev3) $(errhand)
- $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $(alev3) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $(CBLASLIB) $^
$(RANLIB) $(CBLASLIB)
# All levels and precisions
$(CBLASLIB): $(alev1) $(alev2) $(alev3) $(errhand)
- $(ARCH) $(ARCHFLAGS) $@ $(alev1) $(alev2) $(alev3) $(errhand)
+ $(ARCH) $(ARCHFLAGS) $@ $^
$(RANLIB) $@
FRC:
@FRC=$(FRC)
-clean:
- rm -f *.o a.out core
-cleanall:
+clean: cleanobj cleanlib
+cleanobj:
+ rm -f *.o
+cleanlib:
rm -f $(CBLASLIB)
.c.o:
$(CC) $(CFLAGS) -I../include -c -o $@ $<
-
.f.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
endmacro()
-# Object files for single real precision
+# Object files for single precision real
set(STESTL1O c_sblas1.c)
set(STESTL2O c_sblas2.c c_s2chke.c auxiliary.c c_xerbla.c)
set(STESTL3O c_sblas3.c c_s3chke.c auxiliary.c c_xerbla.c)
-# Object files for double real precision
+# Object files for double precision real
set(DTESTL1O c_dblas1.c)
set(DTESTL2O c_dblas2.c c_d2chke.c auxiliary.c c_xerbla.c)
set(DTESTL3O c_dblas3.c c_d3chke.c auxiliary.c c_xerbla.c)
-# Object files for single complex precision
+# Object files for single precision complex
set(CTESTL1O c_cblat1.f c_cblas1.c)
set(CTESTL2O c_cblas2.c c_c2chke.c auxiliary.c c_xerbla.c)
set(CTESTL3O c_cblas3.c c_c3chke.c auxiliary.c c_xerbla.c)
-# Object files for double complex precision
+# Object files for double precision complex
set(ZTESTL1O c_zblas1.c)
set(ZTESTL2O c_zblas2.c c_z2chke.c auxiliary.c c_xerbla.c)
set(ZTESTL3O c_zblas3.c c_z3chke.c auxiliary.c c_xerbla.c)
# Archive files necessary to compile
LIB = $(CBLASLIB) $(BLASLIB)
-# Object files for single real precision
+# Object files for single precision real
stestl1o = c_sblas1.o
stestl2o = c_sblas2.o c_s2chke.o auxiliary.o c_xerbla.o
stestl3o = c_sblas3.o c_s3chke.o auxiliary.o c_xerbla.o
-# Object files for double real precision
+# Object files for double precision real
dtestl1o = c_dblas1.o
dtestl2o = c_dblas2.o c_d2chke.o auxiliary.o c_xerbla.o
dtestl3o = c_dblas3.o c_d3chke.o auxiliary.o c_xerbla.o
-# Object files for single complex precision
+# Object files for single precision complex
ctestl1o = c_cblas1.o
ctestl2o = c_cblas2.o c_c2chke.o auxiliary.o c_xerbla.o
ctestl3o = c_cblas3.o c_c3chke.o auxiliary.o c_xerbla.o
-# Object files for double complex precision
+# Object files for double precision complex
ztestl1o = c_zblas1.o
ztestl2o = c_zblas2.o c_z2chke.o auxiliary.o c_xerbla.o
ztestl3o = c_zblas3.o c_z3chke.o auxiliary.o c_xerbla.o
all: all1 all2 all3
-all1: stest1 dtest1 ctest1 ztest1
-all2: stest2 dtest2 ctest2 ztest2
-all3: stest3 dtest3 ctest3 ztest3
-
-clean:
- rm -f core *.o *.out x*
-cleanobj:
- rm -f core *.o a.out
-cleanexe:
- rm -f x*
-
-stest1: xscblat1
-dtest1: xdcblat1
-ctest1: xccblat1
-ztest1: xzcblat1
-
-stest2: xscblat2
-dtest2: xdcblat2
-ctest2: xccblat2
-ztest2: xzcblat2
-
-stest3: xscblat3
-dtest3: xdcblat3
-ctest3: xccblat3
-ztest3: xzcblat3
+all1: xscblat1 xdcblat1 xccblat1 xzcblat1
+all2: xscblat2 xdcblat2 xccblat2 xzcblat2
+all3: xscblat3 xdcblat3 xccblat3 xzcblat3
#
# Compile each precision
#
# Single real
-xscblat1: $(stestl1o) c_sblat1.o
- $(LOADER) $(LOADOPTS) -o $@ c_sblat1.o $(stestl1o) $(LIB)
-xscblat2: $(stestl2o) c_sblat2.o
- $(LOADER) $(LOADOPTS) -o $@ c_sblat2.o $(stestl2o) $(LIB)
-xscblat3: $(stestl3o) c_sblat3.o
- $(LOADER) $(LOADOPTS) -o $@ c_sblat3.o $(stestl3o) $(LIB)
+xscblat1: c_sblat1.o $(stestl1o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xscblat2: c_sblat2.o $(stestl2o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xscblat3: c_sblat3.o $(stestl3o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
# Double real
-xdcblat1: $(dtestl1o) c_dblat1.o
- $(LOADER) $(LOADOPTS) -o $@ c_dblat1.o $(dtestl1o) $(LIB)
-xdcblat2: $(dtestl2o) c_dblat2.o
- $(LOADER) $(LOADOPTS) -o $@ c_dblat2.o $(dtestl2o) $(LIB)
-xdcblat3: $(dtestl3o) c_dblat3.o
- $(LOADER) $(LOADOPTS) -o $@ c_dblat3.o $(dtestl3o) $(LIB)
+xdcblat1: c_dblat1.o $(dtestl1o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xdcblat2: c_dblat2.o $(dtestl2o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xdcblat3: c_dblat3.o $(dtestl3o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
# Single complex
-xccblat1: $(ctestl1o) c_cblat1.o
- $(LOADER) $(LOADOPTS) -o $@ c_cblat1.o $(ctestl1o) $(LIB)
-xccblat2: $(ctestl2o) c_cblat2.o
- $(LOADER) $(LOADOPTS) -o $@ c_cblat2.o $(ctestl2o) $(LIB)
-xccblat3: $(ctestl3o) c_cblat3.o
- $(LOADER) $(LOADOPTS) -o $@ c_cblat3.o $(ctestl3o) $(LIB)
+xccblat1: c_cblat1.o $(ctestl1o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xccblat2: c_cblat2.o $(ctestl2o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xccblat3: c_cblat3.o $(ctestl3o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
# Double complex
-xzcblat1: $(ztestl1o) c_zblat1.o
- $(LOADER) $(LOADOPTS) -o $@ c_zblat1.o $(ztestl1o) $(LIB)
-xzcblat2: $(ztestl2o) c_zblat2.o
- $(LOADER) $(LOADOPTS) -o $@ c_zblat2.o $(ztestl2o) $(LIB)
-xzcblat3: $(ztestl3o) c_zblat3.o
- $(LOADER) $(LOADOPTS) -o $@ c_zblat3.o $(ztestl3o) $(LIB)
+xzcblat1: c_zblat1.o $(ztestl1o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xzcblat2: c_zblat2.o $(ztestl2o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
+xzcblat3: c_zblat3.o $(ztestl3o) $(LIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
# RUN TESTS
-run:
- @echo "--> TESTING CBLAS 1 - SINGLE PRECISION <--"
+run: all
+ @echo "--> TESTING CBLAS 1 - SINGLE PRECISION REAL <--"
@./xscblat1 > stest1.out
- @echo "--> TESTING CBLAS 1 - DOUBLE PRECISION <--"
+ @echo "--> TESTING CBLAS 1 - DOUBLE PRECISION REAL <--"
@./xdcblat1 > dtest1.out
- @echo "--> TESTING CBLAS 1 - COMPLEX PRECISION <--"
+ @echo "--> TESTING CBLAS 1 - SINGLE PRECISION COMPLEX <--"
@./xccblat1 > ctest1.out
- @echo "--> TESTING CBLAS 1 - DOUBLE COMPLEX PRECISION <--"
+ @echo "--> TESTING CBLAS 1 - DOUBLE PRECISION COMPLEX <--"
@./xzcblat1 > ztest1.out
- @echo "--> TESTING CBLAS 2 - SINGLE PRECISION <--"
+ @echo "--> TESTING CBLAS 2 - SINGLE PRECISION REAL <--"
@./xscblat2 < sin2 > stest2.out
- @echo "--> TESTING CBLAS 2 - DOUBLE PRECISION <--"
+ @echo "--> TESTING CBLAS 2 - DOUBLE PRECISION REAL <--"
@./xdcblat2 < din2 > dtest2.out
- @echo "--> TESTING CBLAS 2 - COMPLEX PRECISION <--"
+ @echo "--> TESTING CBLAS 2 - SINGLE PRECISION COMPLEX <--"
@./xccblat2 < cin2 > ctest2.out
- @echo "--> TESTING CBLAS 2 - DOUBLE COMPLEX PRECISION <--"
+ @echo "--> TESTING CBLAS 2 - DOUBLE PRECISION COMPLEX <--"
@./xzcblat2 < zin2 > ztest2.out
- @echo "--> TESTING CBLAS 3 - SINGLE PRECISION <--"
+ @echo "--> TESTING CBLAS 3 - SINGLE PRECISION REAL <--"
@./xscblat3 < sin3 > stest3.out
- @echo "--> TESTING CBLAS 3 - DOUBLE PRECISION <--"
+ @echo "--> TESTING CBLAS 3 - DOUBLE PRECISION REAL <--"
@./xdcblat3 < din3 > dtest3.out
- @echo "--> TESTING CBLAS 3 - COMPLEX PRECISION <--"
+ @echo "--> TESTING CBLAS 3 - SINGLE PRECISION COMPLEX <--"
@./xccblat3 < cin3 > ctest3.out
- @echo "--> TESTING CBLAS 3 - DOUBLE COMPLEX PRECISION <--"
+ @echo "--> TESTING CBLAS 3 - DOUBLE PRECISION COMPLEX <--"
@./xzcblat3 < zin3 > ztest3.out
-.SUFFIXES: .o .f .c
+clean: cleanobj cleanexe cleantest
+cleanobj:
+ rm -f *.o
+cleanexe:
+ rm -f x*
+cleantest:
+ rm -f *.out core
+.SUFFIXES: .o .f .c
.c.o:
$(CC) $(CFLAGS) -I../include -c -o $@ $<
-
.f.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
\begin{verbatim}
lapacklib:
- ( cd SRC; $(MAKE) single )
+ $(MAKE) -C SRC single
\end{verbatim}
Likewise, you could specify \texttt{double, complex, or complex16} to
\begin{list}{}{}
\item \texttt{cd LAPACK}
-\item \texttt{make clean}
+\item \texttt{make cleanobj}
\end{list}
\section{Further Details of the Installation Process}\label{furtherdetails}
all: testlsame testslamch testdlamch testsecond testdsecnd testieee testversion
-clean:
- rm -f *.o
-cleanall:
- rm -f test*
-
testlsame: lsame.o lsametst.o
- $(LOADER) $(LOADOPTS) -o $@ lsame.o lsametst.o
+ $(LOADER) $(LOADOPTS) -o $@ $^
testslamch: slamch.o lsame.o slamchtst.o
- $(LOADER) $(LOADOPTS) -o $@ slamch.o lsame.o slamchtst.o
+ $(LOADER) $(LOADOPTS) -o $@ $^
testdlamch: dlamch.o lsame.o dlamchtst.o
- $(LOADER) $(LOADOPTS) -o $@ dlamch.o lsame.o dlamchtst.o
+ $(LOADER) $(LOADOPTS) -o $@ $^
testsecond: second_$(TIMER).o secondtst.o
@echo "[INFO] : TIMER value: $(TIMER) (given by make.inc)"
- $(LOADER) $(LOADOPTS) -o $@ second_$(TIMER).o secondtst.o
+ $(LOADER) $(LOADOPTS) -o $@ $^
testdsecnd: dsecnd_$(TIMER).o dsecndtst.o
@echo "[INFO] : TIMER value: $(TIMER) (given by make.inc)"
- $(LOADER) $(LOADOPTS) -o $@ dsecnd_$(TIMER).o dsecndtst.o
+ $(LOADER) $(LOADOPTS) -o $@ $^
testieee: tstiee.o
- $(LOADER) $(LOADOPTS) -o $@ tstiee.o
+ $(LOADER) $(LOADOPTS) -o $@ $^
testversion: ilaver.o LAPACK_version.o
- $(LOADER) $(LOADOPTS) -o $@ ilaver.o LAPACK_version.o
+ $(LOADER) $(LOADOPTS) -o $@ $^
run: all
./testlsame
./testieee
./testversion
+clean: cleanobj cleanexe cleantest
+cleanobj:
+ rm -f *.o
+cleanexe:
+ rm -f test*
+cleantest:
+ rm -f core
+
.SUFFIXES: .o .f
.f.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
# To generate lapacke library type 'make lapacke'
# To make both just type 'make'
#
-# To remove lapacke object files type 'make cleanlib'
+# To remove lapacke object files type 'make cleanobj'
# To clean all above type 'make clean'
# To clean everything including lapacke library type
# 'make cleanall'
all: lapacke
-lapacke:
- cd include && cp lapacke_mangling_with_flags.h.in lapacke_mangling.h
- cd src && $(MAKE)
- cd utils && $(MAKE)
+lapacke: include/lapacke_mangling.h
+ $(MAKE) -C src
+ $(MAKE) -C utils
-lapacke_example:
- cd example && $(MAKE)
+include/lapacke_mangling.h: include/lapacke_mangling_with_flags.h.in
+ cp $< $@
-clean: cleanlib
+lapacke_example: lapacke
+ $(MAKE) -C example
+clean: cleanlib
+ $(MAKE) -C src clean
+ $(MAKE) -C utils clean
+ $(MAKE) -C example clean
+cleanobj:
+ $(MAKE) -C src cleanobj
+ $(MAKE) -C utils cleanobj
+ $(MAKE) -C example cleanobj
cleanlib:
- cd src && $(MAKE) clean
- cd utils && $(MAKE) clean
-
-cleanall: clean
- rm -f $(LAPACKE)
- cd example && $(MAKE) clean
+ rm -f ../$(LAPACKELIB)
+cleanexe:
+ $(MAKE) -C example cleanexe
# Double Precision Examples
xexample_DGESV_rowmajor: example_DGESV_rowmajor.o lapacke_example_aux.o $(LIBRARIES)
- $(LOADER) $(LOADOPTS) -o $@ example_DGESV_rowmajor.o lapacke_example_aux.o $(LIBRARIES)
+ $(LOADER) $(LOADOPTS) -o $@ $^
./$@
xexample_DGESV_colmajor: example_DGESV_colmajor.o lapacke_example_aux.o $(LIBRARIES)
- $(LOADER) $(LOADOPTS) -o $@ example_DGESV_colmajor.o lapacke_example_aux.o $(LIBRARIES)
+ $(LOADER) $(LOADOPTS) -o $@ $^
./$@
xexample_DGELS_rowmajor: example_DGELS_rowmajor.o lapacke_example_aux.o $(LIBRARIES)
- $(LOADER) $(LOADOPTS) -o $@ example_DGELS_rowmajor.o lapacke_example_aux.o $(LIBRARIES)
+ $(LOADER) $(LOADOPTS) -o $@ $^
./$@
xexample_DGELS_colmajor: example_DGELS_colmajor.o lapacke_example_aux.o $(LIBRARIES)
- $(LOADER) $(LOADOPTS) -o $@ example_DGELS_colmajor.o lapacke_example_aux.o $(LIBRARIES)
+ $(LOADER) $(LOADOPTS) -o $@ $^
./$@
+clean: cleanobj cleanexe
+cleanobj:
+ rm -f *.o
+cleanexe:
+ rm -f x*
+
.c.o:
$(CC) $(CFLAGS) -I. -I../include -c -o $@ $<
-
-clean:
- rm -f *.o x*
$(ARCH) $(ARCHFLAGS) $@ $(MATGEN)
$(RANLIB) $@
+clean: cleanobj
+cleanobj:
+ rm -f *.o
+
.c.o:
$(CC) $(CFLAGS) -I../include -c -o $@ $<
-
-clean:
- rm -f *.o
all: lib
lib: $(OBJ)
- $(ARCH) $(ARCHFLAGS) ../../$(LAPACKELIB) $(OBJ)
+ $(ARCH) $(ARCHFLAGS) ../../$(LAPACKELIB) $^
$(RANLIB) ../../$(LAPACKELIB)
+clean: cleanobj
+cleanobj:
+ rm -f *.o
+
.c.o:
$(CC) $(CFLAGS) -I../include -c -o $@ $<
-
-clean:
- rm -f *.o
lib: lapacklib tmglib
#lib: blaslib variants lapacklib tmglib
-clean: cleanlib cleantesting cleanblas_testing cleancblas_testing
-
-lapack_install:
- ( cd INSTALL; $(MAKE) run )
-
blaslib:
- ( cd BLAS/SRC; $(MAKE) )
+ $(MAKE) -C BLAS
cblaslib:
- ( cd CBLAS; $(MAKE) )
+ $(MAKE) -C CBLAS
-lapacklib: lapack_install
- ( cd SRC; $(MAKE) )
+lapacklib:
+ $(MAKE) -C SRC
-lapackelib: lapacklib
- ( cd LAPACKE; $(MAKE) )
-
-cblas_example: cblaslib blaslib
- ( cd CBLAS/examples; $(MAKE) )
+lapackelib:
+ $(MAKE) -C LAPACKE
-lapacke_example: lapackelib
- ( cd LAPACKE/example; $(MAKE) )
+tmglib:
+ $(MAKE) -C TESTING/MATGEN
variants:
- ( cd SRC/VARIANTS; $(MAKE) )
+ $(MAKE) -C SRC/VARIANTS
-tmglib:
- ( cd TESTING/MATGEN; $(MAKE) )
+lapack_install:
+ $(MAKE) -C INSTALL run
-lapack_testing: lib
- ( cd TESTING; $(MAKE) )
- ./lapack_testing.py
+blas_testing: blaslib
+ $(MAKE) -C BLAS blas_testing
-variants_testing: lib variants
- ( cd TESTING; rm -f xlintst*; $(MAKE) VARLIB='SRC/VARIANTS/LIB/cholrl.a'; \
- mv stest.out stest_cholrl.out; mv dtest.out dtest_cholrl.out; mv ctest.out ctest_cholrl.out; mv ztest.out ztest_cholrl.out )
- ( cd TESTING; rm -f xlintst*; $(MAKE) VARLIB='SRC/VARIANTS/LIB/choltop.a'; \
- mv stest.out stest_choltop.out; mv dtest.out dtest_choltop.out; mv ctest.out ctest_choltop.out; mv ztest.out ztest_choltop.out )
- ( cd TESTING; rm -f xlintst*; $(MAKE) VARLIB='SRC/VARIANTS/LIB/lucr.a'; \
- mv stest.out stest_lucr.out; mv dtest.out dtest_lucr.out; mv ctest.out ctest_lucr.out; mv ztest.out ztest_lucr.out )
- ( cd TESTING; rm -f xlintst*; $(MAKE) VARLIB='SRC/VARIANTS/LIB/lull.a'; \
- mv stest.out stest_lull.out; mv dtest.out dtest_lull.out; mv ctest.out ctest_lull.out; mv ztest.out ztest_lull.out )
- ( cd TESTING; rm -f xlintst*; $(MAKE) VARLIB='SRC/VARIANTS/LIB/lurec.a'; \
- mv stest.out stest_lurec.out; mv dtest.out dtest_lurec.out; mv ctest.out ctest_lurec.out; mv ztest.out ztest_lurec.out )
- ( cd TESTING; rm -f xlintst*; $(MAKE) VARLIB='SRC/VARIANTS/LIB/qrll.a'; \
- mv stest.out stest_qrll.out; mv dtest.out dtest_qrll.out; mv ctest.out ctest_qrll.out; mv ztest.out ztest_qrll.out )
+cblas_testing: cblaslib blaslib
+ $(MAKE) -C CBLAS cblas_testing
-blas_testing: blaslib
- ( cd BLAS/TESTING; $(MAKE) run )
+lapack_testing: tmglib lapacklib blaslib
+ $(MAKE) -C TESTING/LIN cleanexe
+ $(MAKE) -C TESTING
+ ./lapack_testing.py
-cblas_testing: blaslib
- ( cd CBLAS; $(MAKE) cblas_testing )
- ( cd CBLAS; $(MAKE) runtst )
+variants_testing: tmglib variants lapacklib blaslib
+ $(MAKE) -C TESTING/LIN cleanexe
+ $(MAKE) -C TESTING/LIN VARLIB='SRC/VARIANTS/cholrl.a'
+ $(MAKE) -C TESTING stest.out && mv TESTING/stest.out TESTING/stest_cholrl.out
+ $(MAKE) -C TESTING dtest.out && mv TESTING/dtest.out TESTING/dtest_cholrl.out
+ $(MAKE) -C TESTING ctest.out && mv TESTING/ctest.out TESTING/ctest_cholrl.out
+ $(MAKE) -C TESTING ztest.out && mv TESTING/ztest.out TESTING/ztest_cholrl.out
+ $(MAKE) -C TESTING/LIN cleanexe
+ $(MAKE) -C TESTING/LIN VARLIB='SRC/VARIANTS/choltop.a'
+ $(MAKE) -C TESTING stest.out && mv TESTING/stest.out TESTING/stest_choltop.out
+ $(MAKE) -C TESTING dtest.out && mv TESTING/dtest.out TESTING/dtest_choltop.out
+ $(MAKE) -C TESTING ctest.out && mv TESTING/ctest.out TESTING/ctest_choltop.out
+ $(MAKE) -C TESTING ztest.out && mv TESTING/ztest.out TESTING/ztest_choltop.out
+ $(MAKE) -C TESTING/LIN cleanexe
+ $(MAKE) -C TESTING/LIN VARLIB='SRC/VARIANTS/lucr.a'
+ $(MAKE) -C TESTING stest.out && mv TESTING/stest.out TESTING/stest_lucr.out
+ $(MAKE) -C TESTING dtest.out && mv TESTING/dtest.out TESTING/dtest_lucr.out
+ $(MAKE) -C TESTING ctest.out && mv TESTING/ctest.out TESTING/ctest_lucr.out
+ $(MAKE) -C TESTING ztest.out && mv TESTING/ztest.out TESTING/ztest_lucr.out
+ $(MAKE) -C TESTING/LIN cleanexe
+ $(MAKE) -C TESTING/LIN VARLIB='SRC/VARIANTS/lull.a'
+ $(MAKE) -C TESTING stest.out && mv TESTING/stest.out TESTING/stest_lull.out
+ $(MAKE) -C TESTING dtest.out && mv TESTING/dtest.out TESTING/dtest_lull.out
+ $(MAKE) -C TESTING ctest.out && mv TESTING/ctest.out TESTING/ctest_lull.out
+ $(MAKE) -C TESTING ztest.out && mv TESTING/ztest.out TESTING/ztest_lull.out
+ $(MAKE) -C TESTING/LIN cleanexe
+ $(MAKE) -C TESTING/LIN VARLIB='SRC/VARIANTS/lurec.a'
+ $(MAKE) -C TESTING stest.out && mv TESTING/stest.out TESTING/stest_lurec.out
+ $(MAKE) -C TESTING dtest.out && mv TESTING/dtest.out TESTING/dtest_lurec.out
+ $(MAKE) -C TESTING ctest.out && mv TESTING/ctest.out TESTING/ctest_lurec.out
+ $(MAKE) -C TESTING ztest.out && mv TESTING/ztest.out TESTING/ztest_lurec.out
+ $(MAKE) -C TESTING/LIN cleanexe
+ $(MAKE) -C TESTING/LIN VARLIB='SRC/VARIANTS/qrll.a'
+ $(MAKE) -C TESTING stest.out && mv TESTING/stest.out TESTING/stest_qrll.out
+ $(MAKE) -C TESTING dtest.out && mv TESTING/dtest.out TESTING/dtest_qrll.out
+ $(MAKE) -C TESTING ctest.out && mv TESTING/ctest.out TESTING/ctest_qrll.out
+ $(MAKE) -C TESTING ztest.out && mv TESTING/ztest.out TESTING/ztest_qrll.out
+cblas_example: cblaslib blaslib
+ $(MAKE) -C CBLAS cblas_example
+lapacke_example: lapackelib lapacklib blaslib
+ $(MAKE) -C LAPACKE lapacke_example
html:
@echo "LAPACK HTML PAGES GENERATION with Doxygen"
@echo "Usage: man dgetrf.f"
@echo "=================="
+clean:
+ $(MAKE) -C INSTALL clean
+ $(MAKE) -C BLAS clean
+ $(MAKE) -C CBLAS clean
+ $(MAKE) -C SRC clean
+ $(MAKE) -C SRC/VARIANTS clean
+ $(MAKE) -C TESTING clean
+ $(MAKE) -C TESTING/MATGEN clean
+ $(MAKE) -C TESTING/LIN clean
+ $(MAKE) -C TESTING/EIG clean
+ $(MAKE) -C LAPACKE clean
+ rm -f *.a
+cleanobj:
+ $(MAKE) -C INSTALL cleanobj
+ $(MAKE) -C BLAS cleanobj
+ $(MAKE) -C CBLAS cleanobj
+ $(MAKE) -C SRC cleanobj
+ $(MAKE) -C SRC/VARIANTS cleanobj
+ $(MAKE) -C TESTING/MATGEN cleanobj
+ $(MAKE) -C TESTING/LIN cleanobj
+ $(MAKE) -C TESTING/EIG cleanobj
+ $(MAKE) -C LAPACKE cleanobj
cleanlib:
- ( cd INSTALL; $(MAKE) clean )
- ( cd BLAS/SRC; $(MAKE) clean )
- ( cd CBLAS; $(MAKE) clean )
- ( cd SRC; $(MAKE) clean )
- ( cd SRC/VARIANTS; $(MAKE) clean )
- ( cd TESTING/MATGEN; $(MAKE) clean )
- ( cd LAPACKE; $(MAKE) clean )
-
-
-cleanblas_testing:
- ( cd BLAS/TESTING; $(MAKE) clean )
-
-cleancblas_testing:
- ( cd CBLAS/testing; $(MAKE) clean )
-
-cleantesting:
- ( cd TESTING/LIN; $(MAKE) clean )
- ( cd TESTING/EIG; $(MAKE) clean )
- ( cd TESTING; rm -f xlin* xeig* )
-
-cleanall: cleanlib cleanblas_testing cleancblas_testing cleantesting
- ( cd INSTALL; $(MAKE) cleanall )
- rm -f *.a TESTING/*.out
+ $(MAKE) -C BLAS cleanlib
+ $(MAKE) -C CBLAS cleanlib
+ $(MAKE) -C SRC cleanlib
+ $(MAKE) -C SRC/VARIANTS cleanlib
+ $(MAKE) -C TESTING/MATGEN cleanlib
+ $(MAKE) -C LAPACKE cleanlib
+ rm -f *.a
+cleanexe:
+ $(MAKE) -C INSTALL cleanexe
+ $(MAKE) -C BLAS cleanexe
+ $(MAKE) -C CBLAS cleanexe
+ $(MAKE) -C TESTING/LIN cleanexe
+ $(MAKE) -C TESTING/EIG cleanexe
+ $(MAKE) -C LAPACKE cleanexe
+cleantest:
+ $(MAKE) -C INSTALL cleantest
+ $(MAKE) -C BLAS cleantest
+ $(MAKE) -C CBLAS cleantest
+ $(MAKE) -C TESTING cleantest
LAPACK project supports the package in the sense that reports of errors or poor
performance will gain immediate attention from the developers. Such reports,
descriptions of interesting applications, and other comments should be sent by
-electronic mail to lapack@cs.utk.edu.
+electronic mail to lapack@icl.utk.edu.
For further information on LAPACK please read our FAQ at
http://www.netlib.org/lapack/#_faq.
A User forum is also available to help you with the LAPACK library at
http://icl.cs.utk.edu/lapack-forum/.
-You can also contact directly the LAPACK team at lapack@cs.utk.edu.
+You can also contact directly the LAPACK team at lapack@icl.utk.edu.
## Testing
# and is created at the next higher directory level.
#
# To remove the object files after the library is created, enter
-# make clean
+# make cleanobj
# On some systems, you can force the source files to be recompiled by
# entering (for example)
# make single FRC=FRC
all: ../$(LAPACKLIB)
../$(LAPACKLIB): $(ALLOBJ) $(ALLXOBJ) $(DEPRECATED)
- $(ARCH) $(ARCHFLAGS) $@ $(ALLOBJ) $(ALLXOBJ) $(DEPRECATED)
+ $(ARCH) $(ARCHFLAGS) $@ $^
$(RANLIB) $@
single: $(SLASRC) $(DSLASRC) $(SXLASRC) $(SCLAUX) $(ALLAUX)
- $(ARCH) $(ARCHFLAGS) ../$(LAPACKLIB) $(SLASRC) $(DSLASRC) \
- $(SXLASRC) $(SCLAUX) $(ALLAUX)
+ $(ARCH) $(ARCHFLAGS) ../$(LAPACKLIB) $^
$(RANLIB) ../$(LAPACKLIB)
complex: $(CLASRC) $(ZCLASRC) $(CXLASRC) $(SCLAUX) $(ALLAUX)
- $(ARCH) $(ARCHFLAGS) ../$(LAPACKLIB) $(CLASRC) $(ZCLASRC) \
- $(CXLASRC) $(SCLAUX) $(ALLAUX)
+ $(ARCH) $(ARCHFLAGS) ../$(LAPACKLIB) $^
$(RANLIB) ../$(LAPACKLIB)
double: $(DLASRC) $(DSLASRC) $(DXLASRC) $(DZLAUX) $(ALLAUX)
- $(ARCH) $(ARCHFLAGS) ../$(LAPACKLIB) $(DLASRC) $(DSLASRC) \
- $(DXLASRC) $(DZLAUX) $(ALLAUX)
+ $(ARCH) $(ARCHFLAGS) ../$(LAPACKLIB) $^
$(RANLIB) ../$(LAPACKLIB)
complex16: $(ZLASRC) $(ZCLASRC) $(ZXLASRC) $(DZLAUX) $(ALLAUX)
- $(ARCH) $(ARCHFLAGS) ../$(LAPACKLIB) $(ZLASRC) $(ZCLASRC) \
- $(ZXLASRC) $(DZLAUX) $(ALLAUX)
+ $(ARCH) $(ARCHFLAGS) ../$(LAPACKLIB) $^
$(RANLIB) ../$(LAPACKLIB)
$(ALLAUX): $(FRC)
FRC:
@FRC=$(FRC)
-clean:
+clean: cleanobj cleanlib
+cleanobj:
rm -f *.o DEPRECATED/*.o
+cleanlib:
+ rm -f ../$(LAPACKLIB)
.f.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
-
.F.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
# 1065-1081. http://dx.doi.org/10.1137/S0895479896297744
#######################################################################
-VARIANTSDIR = LIB
-
CHOLRL = cholesky/RL/cpotrf.o cholesky/RL/dpotrf.o cholesky/RL/spotrf.o cholesky/RL/zpotrf.o
CHOLTOP = cholesky/TOP/cpotrf.o cholesky/TOP/dpotrf.o cholesky/TOP/spotrf.o cholesky/TOP/zpotrf.o
QRLL = qr/LL/cgeqrf.o qr/LL/dgeqrf.o qr/LL/sgeqrf.o qr/LL/zgeqrf.o qr/LL/sceil.o
-all: cholrl choltop lucr lull lurec qrll
+all: cholrl.a choltop.a lucr.a lull.a lurec.a qrll.a
-cholrl: $(CHOLRL)
- $(ARCH) $(ARCHFLAGS) $(VARIANTSDIR)/cholrl.a $(CHOLRL)
- $(RANLIB) $(VARIANTSDIR)/cholrl.a
+cholrl.a: $(CHOLRL)
+ $(ARCH) $(ARCHFLAGS) $@ $^
+ $(RANLIB) $@
-choltop: $(CHOLTOP)
- $(ARCH) $(ARCHFLAGS) $(VARIANTSDIR)/choltop.a $(CHOLTOP)
- $(RANLIB) $(VARIANTSDIR)/choltop.a
+choltop.a: $(CHOLTOP)
+ $(ARCH) $(ARCHFLAGS) $@ $^
+ $(RANLIB) $@
-lucr: $(LUCR)
- $(ARCH) $(ARCHFLAGS) $(VARIANTSDIR)/lucr.a $(LUCR)
- $(RANLIB) $(VARIANTSDIR)/lucr.a
+lucr.a: $(LUCR)
+ $(ARCH) $(ARCHFLAGS) $@ $^
+ $(RANLIB) $@
-lull: $(LULL)
- $(ARCH) $(ARCHFLAGS) $(VARIANTSDIR)/lull.a $(LULL)
- $(RANLIB) $(VARIANTSDIR)/lull.a
+lull.a: $(LULL)
+ $(ARCH) $(ARCHFLAGS) $@ $^
+ $(RANLIB) $@
-lurec: $(LUREC)
- $(ARCH) $(ARCHFLAGS) $(VARIANTSDIR)/lurec.a $(LUREC)
- $(RANLIB) $(VARIANTSDIR)/lurec.a
+lurec.a: $(LUREC)
+ $(ARCH) $(ARCHFLAGS) $@ $^
+ $(RANLIB) $@
-qrll: $(QRLL)
- $(ARCH) $(ARCHFLAGS) $(VARIANTSDIR)/qrll.a $(QRLL)
- $(RANLIB) $(VARIANTSDIR)/qrll.a
+qrll.a: $(QRLL)
+ $(ARCH) $(ARCHFLAGS) $@ $^
+ $(RANLIB) $@
+clean: cleanobj cleanlib
+cleanobj:
+ rm -f $(CHOLRL) $(CHOLTOP) $(LUCR) $(LULL) $(LUREC) $(QRLL)
+cleanlib:
+ rm -f *.a
.f.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
-
-clean:
- rm -f $(CHOLRL) $(CHOLTOP) $(LUCR) $(LULL) $(LUREC) $(QRLL) \
- $(VARIANTSDIR)/*.a
- ===============
- = README File =
+ ===============
+ = README File =
===============
This README File is for the LAPACK driver variants.
=========
These variants are compiled by default in the build process but they are not tested by default.
-The build process creates one new library per variants in the four arithmetics (singel/double/comple/double complex).
-The libraries are in the SRC/VARIANTS/LIB directory.
+The build process creates one new library per variants in the four arithmetics (single real/double real/single complex/double complex).
+The libraries are in the SRC/VARIANTS directory.
-Corresponding libraries created in SRC/VARIANTS/LIB:
+Corresponding libraries created in SRC/VARIANTS:
- LU Crout : lucr.a
- LU Left Looking : lull.a
- LU Sivan Toledo's recursive : lurec.a
Using LU Left Looking version:
$(FORTRAN) -c myprog.f
- $(FORTRAN) -o myexe myprog.o $(PATH TO LAPACK/SRC/VARIANTS/LIB)/lull.a $(LAPACKLIB) $(BLASLIB)
+ $(FORTRAN) -o myexe myprog.o $(PATH TO LAPACK/SRC/VARIANTS)/lull.a $(LAPACKLIB) $(BLASLIB)
===========
= SUPPORT =
*>
*> \verbatim
*>
-*> The matrix V stores the elementary reflectors H(i) in the i-th column
-*> below the diagonal. For example, if M=5 and N=3, the matrix V is
+*> The matrix V stores the elementary reflectors H(i) in the i-th row
+*> above the diagonal. For example, if M=5 and N=3, the matrix V is
*>
*> V = ( 1 v1 v1 v1 v1 )
*> ( 1 v2 v2 v2 )
*>
*> where the vi's represent the vectors which define H(i), which are returned
*> in the matrix A. The 1's along the diagonal of V are not stored in A.
-*> Let K=MIN(M,N). The number of blocks is B = ceiling(K/NB), where each
-*> block is of order NB except for the last block, which is of order
-*> IB = K - (B-1)*NB. For each of the B blocks, a upper triangular block
-*> reflector factor is computed: T1, T2, ..., TB. The NB-by-NB (and IB-by-IB
-*> for the last block) T's are stored in the NB-by-N matrix T as
+*> Let K=MIN(M,N). The number of blocks is B = ceiling(K/MB), where each
+*> block is of order MB except for the last block, which is of order
+*> IB = K - (B-1)*MB. For each of the B blocks, a upper triangular block
+*> reflector factor is computed: T1, T2, ..., TB. The MB-by-MB (and IB-by-IB
+*> for the last block) T's are stored in the MB-by-K matrix T as
*>
*> T = (T1 T2 ... TB).
*> \endverbatim
*>
*> \verbatim
*>
-*> The matrix V stores the elementary reflectors H(i) in the i-th column
-*> below the diagonal. For example, if M=5 and N=3, the matrix V is
+*> The matrix V stores the elementary reflectors H(i) in the i-th row
+*> above the diagonal. For example, if M=5 and N=3, the matrix V is
*>
*> V = ( 1 v1 v1 v1 v1 )
*> ( 1 v2 v2 v2 )
*>
*> \verbatim
*>
-*> CGEMQRT overwrites the general real M-by-N matrix C with
+*> CGEMLQT overwrites the general real M-by-N matrix C with
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'N': Q C C Q
-*> TRANS = 'C': Q**C C C Q**C
+*> TRANS = 'C': Q**H C C Q**H
*>
*> where Q is a complex orthogonal matrix defined as the product of K
*> elementary reflectors:
*>
-*> Q = H(1) H(2) . . . H(K) = I - V C V**C
+*> Q = H(1) H(2) . . . H(K) = I - V T V**H
*>
*> generated using the compact WY representation as returned by CGELQT.
*>
*> \param[in] SIDE
*> \verbatim
*> SIDE is CHARACTER*1
-*> = 'L': apply Q or Q**C from the Left;
-*> = 'R': apply Q or Q**C from the Right.
+*> = 'L': apply Q or Q**H from the Left;
+*> = 'R': apply Q or Q**H from the Right.
*> \endverbatim
*>
*> \param[in] TRANS
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': No transpose, apply Q;
-*> = 'C': Transpose, apply Q**C.
+*> = 'C': Transpose, apply Q**H.
*> \endverbatim
*>
*> \param[in] M
*>
*> \param[in] V
*> \verbatim
-*> V is COMPLEX array, dimension (LDV,K)
+*> V is COMPLEX array, dimension
+*> (LDV,M) if SIDE = 'L',
+*> (LDV,N) if SIDE = 'R'
*> The i-th row must contain the vector which defines the
*> elementary reflector H(i), for i = 1,2,...,k, as returned by
*> DGELQT in the first K rows of its array argument A.
*> \param[in] LDV
*> \verbatim
*> LDV is INTEGER
-*> The leading dimension of the array V.
-*> If SIDE = 'L', LDA >= max(1,M);
-*> if SIDE = 'R', LDA >= max(1,N).
+*> The leading dimension of the array V. LDV >= max(1,K).
*> \endverbatim
*>
*> \param[in] T
*> \verbatim
*> T is COMPLEX array, dimension (LDT,K)
*> The upper triangular factors of the block reflectors
-*> as returned by DGELQT, stored as a MB-by-M matrix.
+*> as returned by DGELQT, stored as a MB-by-K matrix.
*> \endverbatim
*>
*> \param[in] LDT
*> \verbatim
*> C is COMPLEX array, dimension (LDC,N)
*> On entry, the M-by-N matrix C.
-*> On exit, C is overwritten by Q C, Q**C C, C Q**C or C Q.
+*> On exit, C is overwritten by Q C, Q**H C, C Q**H or C Q.
*> \endverbatim
*>
*> \param[in] LDC
*> block is of order NB except for the last block, which is of order
*> IB = K - (B-1)*NB. For each of the B blocks, a upper triangular block
*> reflector factor is computed: T1, T2, ..., TB. The NB-by-NB (and IB-by-IB
-*> for the last block) T's are stored in the NB-by-N matrix T as
+*> for the last block) T's are stored in the NB-by-K matrix T as
*>
*> T = (T1 T2 ... TB).
*> \endverbatim
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': the linear system involves A;
-*> = 'C': the linear system involves A**C.
+*> = 'C': the linear system involves A**H.
*> \endverbatim
*>
*> \param[in] M
EXTERNAL LSAME, SLAMCH, CLANHB, ILAENV
* ..
* .. External Subroutines ..
- EXTERNAL SSCAL, SSTERF, XERBLA, CLASCL, CSTEQR
+ EXTERNAL SSCAL, SSTERF, XERBLA, CLASCL, CSTEQR,
$ CHETRD_2STAGE
* ..
* .. Intrinsic Functions ..
*> of the matrix B. NRHS >= 0.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is COMPLEX array, dimension (LDA,N)
*> Details of factors computed by CHETRF_AA.
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'N': Q * C C * Q
-*> TRANS = 'T': Q**T * C C * Q**T
+*> TRANS = 'T': Q**H * C C * Q**H
*> where Q is a real orthogonal matrix defined as the product of blocked
*> elementary reflectors computed by short wide LQ
*> factorization (CLASWLQ)
*> \param[in] SIDE
*> \verbatim
*> SIDE is CHARACTER*1
-*> = 'L': apply Q or Q**T from the Left;
-*> = 'R': apply Q or Q**T from the Right.
+*> = 'L': apply Q or Q**H from the Left;
+*> = 'R': apply Q or Q**H from the Right.
*> \endverbatim
*>
*> \param[in] TRANS
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': No transpose, apply Q;
-*> = 'T': Transpose, apply Q**T.
+*> = 'C': Transpose, apply Q**H.
*> \endverbatim
*>
*> \param[in] M
*> \verbatim
*> M is INTEGER
-*> The number of rows of the matrix A. M >=0.
+*> The number of rows of the matrix C. M >=0.
*> \endverbatim
*>
*> \param[in] N
*>
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
-*> A is COMPLEX array, dimension (LDA,K)
+*> A is COMPLEX array, dimension
+*> (LDA,M) if SIDE = 'L',
+*> (LDA,N) if SIDE = 'R'
*> The i-th row must contain the vector which defines the blocked
*> elementary reflector H(i), for i = 1,2,...,k, as returned by
-*> DLASWLQ in the first k rows of its array argument A.
+*> CLASWLQ in the first k rows of its array argument A.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*> C is COMPLEX array, dimension (LDC,N)
*> On entry, the M-by-N matrix C.
-*> On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
+*> On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*> \endverbatim
*>
*> \param[in] LDC
* ..
* .. Local Scalars ..
LOGICAL LEFT, RIGHT, TRAN, NOTRAN, LQUERY
- INTEGER I, II, KK, LW , CTR
+ INTEGER I, II, KK, LW, CTR
* ..
* .. External Functions ..
LOGICAL LSAME
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'N': Q * C C * Q
-*> TRANS = 'C': Q**C * C C * Q**C
+*> TRANS = 'C': Q**H * C C * Q**H
*> where Q is a real orthogonal matrix defined as the product
*> of blocked elementary reflectors computed by tall skinny
*> QR factorization (CLATSQR)
*> \param[in] SIDE
*> \verbatim
*> SIDE is CHARACTER*1
-*> = 'L': apply Q or Q**T from the Left;
-*> = 'R': apply Q or Q**T from the Right.
+*> = 'L': apply Q or Q**H from the Left;
+*> = 'R': apply Q or Q**H from the Right.
*> \endverbatim
*>
*> \param[in] TRANS
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': No transpose, apply Q;
-*> = 'C': Conjugate Transpose, apply Q**C.
+*> = 'C': Conjugate Transpose, apply Q**H.
*> \endverbatim
*>
*> \param[in] M
*> N >= NB >= 1.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is COMPLEX array, dimension (LDA,K)
*> The i-th column must contain the vector which defines the
*> \verbatim
*> C is COMPLEX array, dimension (LDC,N)
*> On entry, the M-by-N matrix C.
-*> On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
+*> On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*> \endverbatim
*>
*> \param[in] LDC
*> \verbatim
*> A is COMPLEX array, dimension (LDA,N)
*> On entry, the M-by-N matrix A.
-*> On exit, the elements on and bleow the diagonal
+*> On exit, the elements on and below the diagonal
*> of the array contain the N-by-N lower triangular matrix L;
*> the elements above the diagonal represent Q by the rows
*> of blocked V (see Further Details).
*> \verbatim
*> IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))
*> The vector of pivot indices. Only the elements in positions
-*> K1 through K1+(K2-K1)*INCX of IPIV are accessed.
-*> IPIV(K) = L implies rows K and L are to be interchanged.
+*> K1 through K1+(K2-K1)*abs(INCX) of IPIV are accessed.
+*> IPIV(K1+(K-K1)*abs(INCX)) = L implies rows K and L are to be
+*> interchanged.
*> \endverbatim
*>
*> \param[in] INCX
*> \verbatim
*> INCX is INTEGER
-*> The increment between successive values of IPIV. If IPIV
+*> The increment between successive values of IPIV. If INCX
*> is negative, the pivots are applied in reverse order.
*> \endverbatim
*
* ..
* .. Executable Statements ..
*
-* Interchange row I with row IPIV(I) for each of rows K1 through K2.
+* Interchange row I with row IPIV(K1+(I-K1)*abs(INCX)) for each of rows
+* K1 through K2.
*
IF( INCX.GT.0 ) THEN
IX0 = K1
*> of the matrix B. NRHS >= 0.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is REAL array, dimension (LDA,N)
*> Details of factors computed by CSYTRF_AA.
*>
*> \param[in,out] A
*> \verbatim
-*> A is COMPLEX array, dimension (LDA,N)
-*> On entry, the lower triangular N-by-N matrix A.
+*> A is COMPLEX array, dimension (LDA,M)
+*> On entry, the lower triangular M-by-M matrix A.
*> On exit, the elements on and below the diagonal of the array
*> contain the lower triangular matrix L.
*> \endverbatim
*> \param[in] LDA
*> \verbatim
*> LDA is INTEGER
-*> The leading dimension of the array A. LDA >= max(1,N).
+*> The leading dimension of the array A. LDA >= max(1,M).
*> \endverbatim
*>
*> \param[in,out] B
*> C = [ A ] [ B ]
*>
*>
-*> where A is an lower triangular N-by-N matrix, and B is M-by-N pentagonal
+*> where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
*> matrix consisting of a M-by-(N-L) rectangular matrix B1 on left of a M-by-L
*> upper trapezoidal matrix B2:
*> [ B ] = [ B1 ] [ B2 ]
*> [ B1 ] <- M-by-(N-L) rectangular
-*> [ B2 ] <- M-by-L upper trapezoidal.
+*> [ B2 ] <- M-by-L lower trapezoidal.
*>
*> The lower trapezoidal matrix B2 consists of the first L columns of a
-*> N-by-N lower triangular matrix, where 0 <= L <= MIN(M,N). If L=0,
+*> M-by-M lower triangular matrix, where 0 <= L <= MIN(M,N). If L=0,
*> B is rectangular M-by-N; if M=L=N, B is lower triangular.
*>
*> The matrix W stores the elementary reflectors H(i) in the i-th row
*> above the diagonal (of A) in the M-by-(M+N) input matrix C
*> [ C ] = [ A ] [ B ]
-*> [ A ] <- lower triangular N-by-N
+*> [ A ] <- lower triangular M-by-M
*> [ B ] <- M-by-N pentagonal
*>
*> so that W can be represented as
*> [ W ] = [ I ] [ V ]
-*> [ I ] <- identity, N-by-N
+*> [ I ] <- identity, M-by-M
*> [ V ] <- M-by-N, same form as B.
*>
*> Thus, all of information needed for W is contained on exit in B, which
*>
*> \param[in,out] A
*> \verbatim
-*> A is COMPLEX array, dimension (LDA,N)
+*> A is COMPLEX array, dimension (LDA,M)
*> On entry, the lower triangular M-by-M matrix A.
*> On exit, the elements on and below the diagonal of the array
*> contain the lower triangular matrix L.
*> \param[in] LDA
*> \verbatim
*> LDA is INTEGER
-*> The leading dimension of the array A. LDA >= max(1,N).
+*> The leading dimension of the array A. LDA >= max(1,M).
*> \endverbatim
*>
*> \param[in,out] B
*> C = [ A ][ B ]
*>
*>
-*> where A is an lower triangular N-by-N matrix, and B is M-by-N pentagonal
+*> where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
*> matrix consisting of a M-by-(N-L) rectangular matrix B1 left of a M-by-L
*> upper trapezoidal matrix B2:
*>
*> above the diagonal (of A) in the M-by-(M+N) input matrix C
*>
*> C = [ A ][ B ]
-*> [ A ] <- lower triangular N-by-N
+*> [ A ] <- lower triangular M-by-M
*> [ B ] <- M-by-N pentagonal
*>
*> so that W can be represented as
*>
*> W = [ I ][ V ]
-*> [ I ] <- identity, N-by-N
+*> [ I ] <- identity, M-by-M
*> [ V ] <- M-by-N, same form as B.
*>
*> Thus, all of information needed for W is contained on exit in B, which
*>
*> \verbatim
*>
-*> CTPMQRT applies a complex orthogonal matrix Q obtained from a
-*> "triangular-pentagonal" real block reflector H to a general
-*> real matrix C, which consists of two blocks A and B.
+*> CTPMLQT applies a complex orthogonal matrix Q obtained from a
+*> "triangular-pentagonal" complex block reflector H to a general
+*> complex matrix C, which consists of two blocks A and B.
*> \endverbatim
*
* Arguments:
*> \param[in] SIDE
*> \verbatim
*> SIDE is CHARACTER*1
-*> = 'L': apply Q or Q**C from the Left;
-*> = 'R': apply Q or Q**C from the Right.
+*> = 'L': apply Q or Q**H from the Left;
+*> = 'R': apply Q or Q**H from the Right.
*> \endverbatim
*>
*> \param[in] TRANS
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': No transpose, apply Q;
-*> = 'C': Transpose, apply Q**C.
+*> = 'C': Transpose, apply Q**H.
*> \endverbatim
*>
*> \param[in] M
*> (LDA,K) if SIDE = 'R'
*> On entry, the K-by-N or M-by-K matrix A.
*> On exit, A is overwritten by the corresponding block of
-*> Q*C or Q**C*C or C*Q or C*Q**C. See Further Details.
+*> Q*C or Q**H*C or C*Q or C*Q**H. See Further Details.
*> \endverbatim
*>
*> \param[in] LDA
*> B is COMPLEX array, dimension (LDB,N)
*> On entry, the M-by-N matrix B.
*> On exit, B is overwritten by the corresponding block of
-*> Q*C or Q**C*C or C*Q or C*Q**C. See Further Details.
+*> Q*C or Q**H*C or C*Q or C*Q**H. See Further Details.
*> \endverbatim
*>
*> \param[in] LDB
*>
*> If TRANS='N' and SIDE='L', C is on exit replaced with Q * C.
*>
-*> If TRANS='C' and SIDE='L', C is on exit replaced with Q**C * C.
+*> If TRANS='C' and SIDE='L', C is on exit replaced with Q**H * C.
*>
*> If TRANS='N' and SIDE='R', C is on exit replaced with C * Q.
*>
-*> If TRANS='C' and SIDE='R', C is on exit replaced with C * Q**C.
+*> If TRANS='C' and SIDE='R', C is on exit replaced with C * Q**H.
*> \endverbatim
*>
* =====================================================================
*>
*> \verbatim
*>
-*> The matrix V stores the elementary reflectors H(i) in the i-th column
-*> below the diagonal. For example, if M=5 and N=3, the matrix V is
+*> The matrix V stores the elementary reflectors H(i) in the i-th row
+*> above the diagonal. For example, if M=5 and N=3, the matrix V is
*>
*> V = ( 1 v1 v1 v1 v1 )
*> ( 1 v2 v2 v2 )
*>
*> where the vi's represent the vectors which define H(i), which are returned
*> in the matrix A. The 1's along the diagonal of V are not stored in A.
-*> Let K=MIN(M,N). The number of blocks is B = ceiling(K/NB), where each
-*> block is of order NB except for the last block, which is of order
-*> IB = K - (B-1)*NB. For each of the B blocks, a upper triangular block
-*> reflector factor is computed: T1, T2, ..., TB. The NB-by-NB (and IB-by-IB
-*> for the last block) T's are stored in the NB-by-N matrix T as
+*> Let K=MIN(M,N). The number of blocks is B = ceiling(K/MB), where each
+*> block is of order MB except for the last block, which is of order
+*> IB = K - (B-1)*MB. For each of the B blocks, a upper triangular block
+*> reflector factor is computed: T1, T2, ..., TB. The MB-by-MB (and IB-by-IB
+*> for the last block) T's are stored in the MB-by-K matrix T as
*>
*> T = (T1 T2 ... TB).
*> \endverbatim
*>
*> \verbatim
*>
-*> The matrix V stores the elementary reflectors H(i) in the i-th column
-*> below the diagonal. For example, if M=5 and N=3, the matrix V is
+*> The matrix V stores the elementary reflectors H(i) in the i-th row
+*> above the diagonal. For example, if M=5 and N=3, the matrix V is
*>
*> V = ( 1 v1 v1 v1 v1 )
*> ( 1 v2 v2 v2 )
* http://www.netlib.org/lapack/explore-html/
*
*> \htmlonly
-*> Download DGEMQRT + dependencies
+*> Download DGEMLQT + dependencies
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dgemlqt.f">
*> [TGZ]</a>
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dgemlqt.f">
*>
*> \verbatim
*>
-*> DGEMQRT overwrites the general real M-by-N matrix C with
+*> DGEMLQT overwrites the general real M-by-N matrix C with
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'N': Q C C Q
*>
*> \param[in] V
*> \verbatim
-*> V is DOUBLE PRECISION array, dimension (LDV,K)
+*> V is DOUBLE PRECISION array, dimension
+*> (LDV,M) if SIDE = 'L',
+*> (LDV,N) if SIDE = 'R'
*> The i-th row must contain the vector which defines the
*> elementary reflector H(i), for i = 1,2,...,k, as returned by
*> DGELQT in the first K rows of its array argument A.
*> \param[in] LDV
*> \verbatim
*> LDV is INTEGER
-*> The leading dimension of the array V.
-*> If SIDE = 'L', LDA >= max(1,M);
-*> if SIDE = 'R', LDA >= max(1,N).
+*> The leading dimension of the array V. LDV >= max(1,K).
*> \endverbatim
*>
*> \param[in] T
*> \verbatim
*> T is DOUBLE PRECISION array, dimension (LDT,K)
*> The upper triangular factors of the block reflectors
-*> as returned by DGELQT, stored as a MB-by-M matrix.
+*> as returned by DGELQT, stored as a MB-by-K matrix.
*> \endverbatim
*>
*> \param[in] LDT
*> block is of order NB except for the last block, which is of order
*> IB = K - (B-1)*NB. For each of the B blocks, a upper triangular block
*> reflector factor is computed: T1, T2, ..., TB. The NB-by-NB (and IB-by-IB
-*> for the last block) T's are stored in the NB-by-N matrix T as
+*> for the last block) T's are stored in the NB-by-K matrix T as
*>
*> T = (T1 T2 ... TB).
*> \endverbatim
*> \param[in] M
*> \verbatim
*> M is INTEGER
-*> The number of rows of the matrix A. M >=0.
+*> The number of rows of the matrix C. M >=0.
*> \endverbatim
*>
*> \param[in] N
*>
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
-*> A is DOUBLE PRECISION array, dimension (LDA,K)
+*> A is DOUBLE PRECISION array, dimension
+*> (LDA,M) if SIDE = 'L',
+*> (LDA,N) if SIDE = 'R'
*> The i-th row must contain the vector which defines the blocked
*> elementary reflector H(i), for i = 1,2,...,k, as returned by
*> DLASWLQ in the first k rows of its array argument A.
*> N >= NB >= 1.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is DOUBLE PRECISION array, dimension (LDA,K)
*> The i-th column must contain the vector which defines the
*> \verbatim
*> A is DOUBLE PRECISION array, dimension (LDA,N)
*> On entry, the M-by-N matrix A.
-*> On exit, the elements on and bleow the diagonal
+*> On exit, the elements on and below the diagonal
*> of the array contain the N-by-N lower triangular matrix L;
*> the elements above the diagonal represent Q by the rows
*> of blocked V (see Further Details).
*> \verbatim
*> IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))
*> The vector of pivot indices. Only the elements in positions
-*> K1 through K1+(K2-K1)*INCX of IPIV are accessed.
-*> IPIV(K) = L implies rows K and L are to be interchanged.
+*> K1 through K1+(K2-K1)*abs(INCX) of IPIV are accessed.
+*> IPIV(K1+(K-K1)*abs(INCX)) = L implies rows K and L are to be
+*> interchanged.
*> \endverbatim
*>
*> \param[in] INCX
*> \verbatim
*> INCX is INTEGER
-*> The increment between successive values of IPIV. If IPIV
+*> The increment between successive values of IPIV. If INCX
*> is negative, the pivots are applied in reverse order.
*> \endverbatim
*
* ..
* .. Executable Statements ..
*
-* Interchange row I with row IPIV(I) for each of rows K1 through K2.
+* Interchange row I with row IPIV(K1+(I-K1)*abs(INCX)) for each of rows
+* K1 through K2.
*
IF( INCX.GT.0 ) THEN
IX0 = K1
EXTERNAL LSAME, DLAMCH, DLANSB, ILAENV
* ..
* .. External Subroutines ..
- EXTERNAL DLASCL, DSCAL, DSTEQR, DSTERF, XERBLA
+ EXTERNAL DLASCL, DSCAL, DSTEQR, DSTERF, XERBLA,
$ DSYTRD_SB2ST
* ..
* .. Intrinsic Functions ..
*> of the matrix B. NRHS >= 0.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is DOUBLE PRECISION array, dimension (LDA,N)
*> Details of factors computed by DSYTRF_AA.
*>
*> \param[in,out] A
*> \verbatim
-*> A is DOUBLE PRECISION array, dimension (LDA,N)
-*> On entry, the lower triangular N-by-N matrix A.
+*> A is DOUBLE PRECISION array, dimension (LDA,M)
+*> On entry, the lower triangular M-by-M matrix A.
*> On exit, the elements on and below the diagonal of the array
*> contain the lower triangular matrix L.
*> \endverbatim
*> \param[in] LDA
*> \verbatim
*> LDA is INTEGER
-*> The leading dimension of the array A. LDA >= max(1,N).
+*> The leading dimension of the array A. LDA >= max(1,M).
*> \endverbatim
*>
*> \param[in,out] B
*> C = [ A ] [ B ]
*>
*>
-*> where A is an lower triangular N-by-N matrix, and B is M-by-N pentagonal
+*> where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
*> matrix consisting of a M-by-(N-L) rectangular matrix B1 on left of a M-by-L
*> upper trapezoidal matrix B2:
*> [ B ] = [ B1 ] [ B2 ]
*> [ B1 ] <- M-by-(N-L) rectangular
-*> [ B2 ] <- M-by-L upper trapezoidal.
+*> [ B2 ] <- M-by-L lower trapezoidal.
*>
*> The lower trapezoidal matrix B2 consists of the first L columns of a
-*> N-by-N lower triangular matrix, where 0 <= L <= MIN(M,N). If L=0,
+*> M-by-M lower triangular matrix, where 0 <= L <= MIN(M,N). If L=0,
*> B is rectangular M-by-N; if M=L=N, B is lower triangular.
*>
*> The matrix W stores the elementary reflectors H(i) in the i-th row
*> above the diagonal (of A) in the M-by-(M+N) input matrix C
*> [ C ] = [ A ] [ B ]
-*> [ A ] <- lower triangular N-by-N
+*> [ A ] <- lower triangular M-by-M
*> [ B ] <- M-by-N pentagonal
*>
*> so that W can be represented as
*> [ W ] = [ I ] [ V ]
-*> [ I ] <- identity, N-by-N
+*> [ I ] <- identity, M-by-M
*> [ V ] <- M-by-N, same form as B.
*>
*> Thus, all of information needed for W is contained on exit in B, which
*>
*> \param[in,out] A
*> \verbatim
-*> A is DOUBLE PRECISION array, dimension (LDA,N)
+*> A is DOUBLE PRECISION array, dimension (LDA,M)
*> On entry, the lower triangular M-by-M matrix A.
*> On exit, the elements on and below the diagonal of the array
*> contain the lower triangular matrix L.
*> \param[in] LDA
*> \verbatim
*> LDA is INTEGER
-*> The leading dimension of the array A. LDA >= max(1,N).
+*> The leading dimension of the array A. LDA >= max(1,M).
*> \endverbatim
*>
*> \param[in,out] B
*> C = [ A ][ B ]
*>
*>
-*> where A is an lower triangular N-by-N matrix, and B is M-by-N pentagonal
+*> where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
*> matrix consisting of a M-by-(N-L) rectangular matrix B1 left of a M-by-L
*> upper trapezoidal matrix B2:
*>
*> above the diagonal (of A) in the M-by-(M+N) input matrix C
*>
*> C = [ A ][ B ]
-*> [ A ] <- lower triangular N-by-N
+*> [ A ] <- lower triangular M-by-M
*> [ B ] <- M-by-N pentagonal
*>
*> so that W can be represented as
*>
*> W = [ I ][ V ]
-*> [ I ] <- identity, N-by-N
+*> [ I ] <- identity, M-by-M
*> [ V ] <- M-by-N, same form as B.
*>
*> Thus, all of information needed for W is contained on exit in B, which
*>
*> \verbatim
*>
-*> The matrix V stores the elementary reflectors H(i) in the i-th column
-*> below the diagonal. For example, if M=5 and N=3, the matrix V is
+*> The matrix V stores the elementary reflectors H(i) in the i-th row
+*> above the diagonal. For example, if M=5 and N=3, the matrix V is
*>
*> V = ( 1 v1 v1 v1 v1 )
*> ( 1 v2 v2 v2 )
*>
*> where the vi's represent the vectors which define H(i), which are returned
*> in the matrix A. The 1's along the diagonal of V are not stored in A.
-*> Let K=MIN(M,N). The number of blocks is B = ceiling(K/NB), where each
-*> block is of order NB except for the last block, which is of order
-*> IB = K - (B-1)*NB. For each of the B blocks, a upper triangular block
-*> reflector factor is computed: T1, T2, ..., TB. The NB-by-NB (and IB-by-IB
-*> for the last block) T's are stored in the NB-by-N matrix T as
+*> Let K=MIN(M,N). The number of blocks is B = ceiling(K/MB), where each
+*> block is of order MB except for the last block, which is of order
+*> IB = K - (B-1)*MB. For each of the B blocks, a upper triangular block
+*> reflector factor is computed: T1, T2, ..., TB. The MB-by-MB (and IB-by-IB
+*> for the last block) T's are stored in the MB-by-K matrix T as
*>
*> T = (T1 T2 ... TB).
*> \endverbatim
*>
*> \verbatim
*>
-*> The matrix V stores the elementary reflectors H(i) in the i-th column
-*> below the diagonal. For example, if M=5 and N=3, the matrix V is
+*> The matrix V stores the elementary reflectors H(i) in the i-th row
+*> above the diagonal. For example, if M=5 and N=3, the matrix V is
*>
*> V = ( 1 v1 v1 v1 v1 )
*> ( 1 v2 v2 v2 )
*>
*> \verbatim
*>
-*> DGEMQRT overwrites the general real M-by-N matrix C with
+*> DGEMLQT overwrites the general real M-by-N matrix C with
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'N': Q C C Q
*>
*> \param[in] V
*> \verbatim
-*> V is REAL array, dimension (LDV,K)
+*> V is REAL array, dimension
+*> (LDV,M) if SIDE = 'L',
+*> (LDV,N) if SIDE = 'R'
*> The i-th row must contain the vector which defines the
*> elementary reflector H(i), for i = 1,2,...,k, as returned by
*> DGELQT in the first K rows of its array argument A.
*> \param[in] LDV
*> \verbatim
*> LDV is INTEGER
-*> The leading dimension of the array V.
-*> If SIDE = 'L', LDA >= max(1,M);
-*> if SIDE = 'R', LDA >= max(1,N).
+*> The leading dimension of the array V. LDV >= max(1,K).
*> \endverbatim
*>
*> \param[in] T
*> \verbatim
*> T is REAL array, dimension (LDT,K)
*> The upper triangular factors of the block reflectors
-*> as returned by DGELQT, stored as a MB-by-M matrix.
+*> as returned by DGELQT, stored as a MB-by-K matrix.
*> \endverbatim
*>
*> \param[in] LDT
*> block is of order NB except for the last block, which is of order
*> IB = K - (B-1)*NB. For each of the B blocks, a upper triangular block
*> reflector factor is computed: T1, T2, ..., TB. The NB-by-NB (and IB-by-IB
-*> for the last block) T's are stored in the NB-by-N matrix T as
+*> for the last block) T's are stored in the NB-by-K matrix T as
*>
*> T = (T1 T2 ... TB).
*> \endverbatim
*>
*> \verbatim
*>
-*> DLAMQRTS overwrites the general real M-by-N matrix C with
+*> SLAMSWLQ overwrites the general real M-by-N matrix C with
*>
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'T': Q**T * C C * Q**T
*> where Q is a real orthogonal matrix defined as the product of blocked
*> elementary reflectors computed by short wide LQ
-*> factorization (DLASWLQ)
+*> factorization (SLASWLQ)
*> \endverbatim
*
* Arguments:
*> \param[in] M
*> \verbatim
*> M is INTEGER
-*> The number of rows of the matrix A. M >=0.
+*> The number of rows of the matrix C. M >=0.
*> \endverbatim
*>
*> \param[in] N
*>
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
-*> A is REAL array, dimension (LDA,K)
+*> A is REAL array, dimension
+*> (LDA,M) if SIDE = 'L',
+*> (LDA,N) if SIDE = 'R'
*> The i-th row must contain the vector which defines the blocked
*> elementary reflector H(i), for i = 1,2,...,k, as returned by
-*> DLASWLQ in the first k rows of its array argument A.
+*> SLASWLQ in the first k rows of its array argument A.
*> \endverbatim
*>
*> \param[in] LDA
*> N >= NB >= 1.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is REAL array, dimension (LDA,K)
*> The i-th column must contain the vector which defines the
*> \verbatim
*> A is REAL array, dimension (LDA,N)
*> On entry, the M-by-N matrix A.
-*> On exit, the elements on and bleow the diagonal
+*> On exit, the elements on and below the diagonal
*> of the array contain the N-by-N lower triangular matrix L;
*> the elements above the diagonal represent Q by the rows
*> of blocked V (see Further Details).
*> \verbatim
*> IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))
*> The vector of pivot indices. Only the elements in positions
-*> K1 through K1+(K2-K1)*INCX of IPIV are accessed.
-*> IPIV(K) = L implies rows K and L are to be interchanged.
+*> K1 through K1+(K2-K1)*abs(INCX) of IPIV are accessed.
+*> IPIV(K1+(K-K1)*abs(INCX)) = L implies rows K and L are to be
+*> interchanged.
*> \endverbatim
*>
*> \param[in] INCX
*> \verbatim
*> INCX is INTEGER
-*> The increment between successive values of IPIV. If IPIV
+*> The increment between successive values of IPIV. If INCX
*> is negative, the pivots are applied in reverse order.
*> \endverbatim
*
* ..
* .. Executable Statements ..
*
-* Interchange row I with row IPIV(I) for each of rows K1 through K2.
+* Interchange row I with row IPIV(K1+(I-K1)*abs(INCX)) for each of rows
+* K1 through K2.
*
IF( INCX.GT.0 ) THEN
IX0 = K1
EXTERNAL LSAME, SLAMCH, SLANSB, ILAENV
* ..
* .. External Subroutines ..
- EXTERNAL SLASCL, SSCAL, SSTEQR, SSTERF, XERBLA
+ EXTERNAL SLASCL, SSCAL, SSTEQR, SSTERF, XERBLA,
$ SSYTRD_SB2ST
* ..
* .. Intrinsic Functions ..
*> of the matrix B. NRHS >= 0.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is REAL array, dimension (LDA,N)
*> Details of factors computed by SSYTRF_AA.
*>
*> \param[in,out] A
*> \verbatim
-*> A is REAL array, dimension (LDA,N)
-*> On entry, the lower triangular N-by-N matrix A.
+*> A is REAL array, dimension (LDA,M)
+*> On entry, the lower triangular M-by-M matrix A.
*> On exit, the elements on and below the diagonal of the array
*> contain the lower triangular matrix L.
*> \endverbatim
*> \param[in] LDA
*> \verbatim
*> LDA is INTEGER
-*> The leading dimension of the array A. LDA >= max(1,N).
+*> The leading dimension of the array A. LDA >= max(1,M).
*> \endverbatim
*>
*> \param[in,out] B
*> C = [ A ] [ B ]
*>
*>
-*> where A is an lower triangular N-by-N matrix, and B is M-by-N pentagonal
+*> where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
*> matrix consisting of a M-by-(N-L) rectangular matrix B1 on left of a M-by-L
*> upper trapezoidal matrix B2:
*> [ B ] = [ B1 ] [ B2 ]
*> [ B1 ] <- M-by-(N-L) rectangular
-*> [ B2 ] <- M-by-L upper trapezoidal.
+*> [ B2 ] <- M-by-L lower trapezoidal.
*>
*> The lower trapezoidal matrix B2 consists of the first L columns of a
-*> N-by-N lower triangular matrix, where 0 <= L <= MIN(M,N). If L=0,
+*> M-by-M lower triangular matrix, where 0 <= L <= MIN(M,N). If L=0,
*> B is rectangular M-by-N; if M=L=N, B is lower triangular.
*>
*> The matrix W stores the elementary reflectors H(i) in the i-th row
*> above the diagonal (of A) in the M-by-(M+N) input matrix C
*> [ C ] = [ A ] [ B ]
-*> [ A ] <- lower triangular N-by-N
+*> [ A ] <- lower triangular M-by-M
*> [ B ] <- M-by-N pentagonal
*>
*> so that W can be represented as
*> [ W ] = [ I ] [ V ]
-*> [ I ] <- identity, N-by-N
+*> [ I ] <- identity, M-by-M
*> [ V ] <- M-by-N, same form as B.
*>
*> Thus, all of information needed for W is contained on exit in B, which
*>
*> \param[in,out] A
*> \verbatim
-*> A is REAL array, dimension (LDA,N)
+*> A is REAL array, dimension (LDA,M)
*> On entry, the lower triangular M-by-M matrix A.
*> On exit, the elements on and below the diagonal of the array
*> contain the lower triangular matrix L.
*> \param[in] LDA
*> \verbatim
*> LDA is INTEGER
-*> The leading dimension of the array A. LDA >= max(1,N).
+*> The leading dimension of the array A. LDA >= max(1,M).
*> \endverbatim
*>
*> \param[in,out] B
*> C = [ A ][ B ]
*>
*>
-*> where A is an lower triangular N-by-N matrix, and B is M-by-N pentagonal
+*> where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
*> matrix consisting of a M-by-(N-L) rectangular matrix B1 left of a M-by-L
*> upper trapezoidal matrix B2:
*>
*> above the diagonal (of A) in the M-by-(M+N) input matrix C
*>
*> C = [ A ][ B ]
-*> [ A ] <- lower triangular N-by-N
+*> [ A ] <- lower triangular M-by-M
*> [ B ] <- M-by-N pentagonal
*>
*> so that W can be represented as
*>
*> W = [ I ][ V ]
-*> [ I ] <- identity, N-by-N
+*> [ I ] <- identity, M-by-M
*> [ V ] <- M-by-N, same form as B.
*>
*> Thus, all of information needed for W is contained on exit in B, which
*>
*> \verbatim
*>
-*> The matrix V stores the elementary reflectors H(i) in the i-th column
-*> below the diagonal. For example, if M=5 and N=3, the matrix V is
+*> The matrix V stores the elementary reflectors H(i) in the i-th row
+*> above the diagonal. For example, if M=5 and N=3, the matrix V is
*>
*> V = ( 1 v1 v1 v1 v1 )
*> ( 1 v2 v2 v2 )
*>
*> where the vi's represent the vectors which define H(i), which are returned
*> in the matrix A. The 1's along the diagonal of V are not stored in A.
-*> Let K=MIN(M,N). The number of blocks is B = ceiling(K/NB), where each
-*> block is of order NB except for the last block, which is of order
-*> IB = K - (B-1)*NB. For each of the B blocks, a upper triangular block
-*> reflector factor is computed: T1, T2, ..., TB. The NB-by-NB (and IB-by-IB
-*> for the last block) T's are stored in the NB-by-N matrix T as
+*> Let K=MIN(M,N). The number of blocks is B = ceiling(K/MB), where each
+*> block is of order MB except for the last block, which is of order
+*> IB = K - (B-1)*MB. For each of the B blocks, a upper triangular block
+*> reflector factor is computed: T1, T2, ..., TB. The MB-by-MB (and IB-by-IB
+*> for the last block) T's are stored in the MB-by-K matrix T as
*>
*> T = (T1 T2 ... TB).
*> \endverbatim
*>
*> \verbatim
*>
-*> The matrix V stores the elementary reflectors H(i) in the i-th column
-*> below the diagonal. For example, if M=5 and N=3, the matrix V is
+*> The matrix V stores the elementary reflectors H(i) in the i-th row
+*> above the diagonal. For example, if M=5 and N=3, the matrix V is
*>
*> V = ( 1 v1 v1 v1 v1 )
*> ( 1 v2 v2 v2 )
* http://www.netlib.org/lapack/explore-html/
*
*> \htmlonly
-*> Download DGEMQRT + dependencies
+*> Download DGEMLQT + dependencies
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zgemlqt.f">
*> [TGZ]</a>
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zgemlqt.f">
*>
*> \verbatim
*>
-*> ZGEMQRT overwrites the general real M-by-N matrix C with
+*> ZGEMLQT overwrites the general real M-by-N matrix C with
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'N': Q C C Q
-*> TRANS = 'C': Q**C C C Q**C
+*> TRANS = 'C': Q**H C C Q**H
*>
*> where Q is a complex orthogonal matrix defined as the product of K
*> elementary reflectors:
*>
-*> Q = H(1) H(2) . . . H(K) = I - V C V**C
+*> Q = H(1) H(2) . . . H(K) = I - V T V**H
*>
*> generated using the compact WY representation as returned by ZGELQT.
*>
*> \param[in] SIDE
*> \verbatim
*> SIDE is CHARACTER*1
-*> = 'L': apply Q or Q**C from the Left;
-*> = 'R': apply Q or Q**C from the Right.
+*> = 'L': apply Q or Q**H from the Left;
+*> = 'R': apply Q or Q**H from the Right.
*> \endverbatim
*>
*> \param[in] TRANS
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': No transpose, apply Q;
-*> = 'C': Transpose, apply Q**C.
+*> = 'C': Transpose, apply Q**H.
*> \endverbatim
*>
*> \param[in] M
*>
*> \param[in] V
*> \verbatim
-*> V is COMPLEX*16 array, dimension (LDV,K)
+*> V is COMPLEX*16 array, dimension
+*> (LDV,M) if SIDE = 'L',
+*> (LDV,N) if SIDE = 'R'
*> The i-th row must contain the vector which defines the
*> elementary reflector H(i), for i = 1,2,...,k, as returned by
*> DGELQT in the first K rows of its array argument A.
*> \param[in] LDV
*> \verbatim
*> LDV is INTEGER
-*> The leading dimension of the array V.
-*> If SIDE = 'L', LDA >= max(1,M);
-*> if SIDE = 'R', LDA >= max(1,N).
+*> The leading dimension of the array V. LDV >= max(1,K).
*> \endverbatim
*>
*> \param[in] T
*> \verbatim
*> T is COMPLEX*16 array, dimension (LDT,K)
*> The upper triangular factors of the block reflectors
-*> as returned by DGELQT, stored as a MB-by-M matrix.
+*> as returned by DGELQT, stored as a MB-by-K matrix.
*> \endverbatim
*>
*> \param[in] LDT
*> \verbatim
*> C is COMPLEX*16 array, dimension (LDC,N)
*> On entry, the M-by-N matrix C.
-*> On exit, C is overwritten by Q C, Q**C C, C Q**C or C Q.
+*> On exit, C is overwritten by Q C, Q**H C, C Q**H or C Q.
*> \endverbatim
*>
*> \param[in] LDC
*> block is of order NB except for the last block, which is of order
*> IB = K - (B-1)*NB. For each of the B blocks, a upper triangular block
*> reflector factor is computed: T1, T2, ..., TB. The NB-by-NB (and IB-by-IB
-*> for the last block) T's are stored in the NB-by-N matrix T as
+*> for the last block) T's are stored in the NB-by-K matrix T as
*>
*> T = (T1 T2 ... TB).
*> \endverbatim
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': the linear system involves A;
-*> = 'C': the linear system involves A**C.
+*> = 'C': the linear system involves A**H.
*> \endverbatim
*>
*> \param[in] M
EXTERNAL LSAME, DLAMCH, ZLANHB, ILAENV
* ..
* .. External Subroutines ..
- EXTERNAL DSCAL, DSTERF, XERBLA, ZLASCL, ZSTEQR
+ EXTERNAL DSCAL, DSTERF, XERBLA, ZLASCL, ZSTEQR,
$ ZHETRD_2STAGE
* ..
* .. Intrinsic Functions ..
*> of the matrix B. NRHS >= 0.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is COMPLEX*16 array, dimension (LDA,N)
*> Details of factors computed by ZHETRF_AA.
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'N': Q * C C * Q
-*> TRANS = 'T': Q**T * C C * Q**T
+*> TRANS = 'C': Q**H * C C * Q**H
*> where Q is a real orthogonal matrix defined as the product of blocked
*> elementary reflectors computed by short wide LQ
*> factorization (ZLASWLQ)
*> \param[in] SIDE
*> \verbatim
*> SIDE is CHARACTER*1
-*> = 'L': apply Q or Q**T from the Left;
-*> = 'R': apply Q or Q**T from the Right.
+*> = 'L': apply Q or Q**H from the Left;
+*> = 'R': apply Q or Q**H from the Right.
*> \endverbatim
*>
*> \param[in] TRANS
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': No transpose, apply Q;
-*> = 'T': Transpose, apply Q**T.
+*> = 'C': Conjugate Transpose, apply Q**H.
*> \endverbatim
*>
*> \param[in] M
*> \verbatim
*> M is INTEGER
-*> The number of rows of the matrix A. M >=0.
+*> The number of rows of the matrix C. M >=0.
*> \endverbatim
*>
*> \param[in] N
*>
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
-*> A is COMPLEX*16 array, dimension (LDA,K)
+*> A is COMPLEX*16 array, dimension
+*> (LDA,M) if SIDE = 'L',
+*> (LDA,N) if SIDE = 'R'
*> The i-th row must contain the vector which defines the blocked
*> elementary reflector H(i), for i = 1,2,...,k, as returned by
-*> DLASWLQ in the first k rows of its array argument A.
+*> ZLASWLQ in the first k rows of its array argument A.
*> \endverbatim
*>
*> \param[in] LDA
*> \verbatim
*> C is COMPLEX*16 array, dimension (LDC,N)
*> On entry, the M-by-N matrix C.
-*> On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
+*> On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*> \endverbatim
*>
*> \param[in] LDC
*
* .. Scalar Arguments ..
CHARACTER SIDE, TRANS
- INTEGER INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC, LW
+ INTEGER INFO, LDA, M, N, K, MB, NB, LDT, LWORK, LDC
* ..
* .. Array Arguments ..
COMPLEX*16 A( LDA, * ), WORK( * ), C(LDC, * ),
* ..
* .. Local Scalars ..
LOGICAL LEFT, RIGHT, TRAN, NOTRAN, LQUERY
- INTEGER I, II, KK, CTR
+ INTEGER I, II, KK, LW, CTR
* ..
* .. External Functions ..
LOGICAL LSAME
*>
*> SIDE = 'L' SIDE = 'R'
*> TRANS = 'N': Q * C C * Q
-*> TRANS = 'C': Q**C * C C * Q**C
+*> TRANS = 'C': Q**H * C C * Q**H
*> where Q is a real orthogonal matrix defined as the product
*> of blocked elementary reflectors computed by tall skinny
*> QR factorization (ZLATSQR)
*> \param[in] SIDE
*> \verbatim
*> SIDE is CHARACTER*1
-*> = 'L': apply Q or Q**T from the Left;
-*> = 'R': apply Q or Q**T from the Right.
+*> = 'L': apply Q or Q**H from the Left;
+*> = 'R': apply Q or Q**H from the Right.
*> \endverbatim
*>
*> \param[in] TRANS
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': No transpose, apply Q;
-*> = 'C': Conjugate Transpose, apply Q**C.
+*> = 'C': Conjugate Transpose, apply Q**H.
*> \endverbatim
*>
*> \param[in] M
*> N >= NB >= 1.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is COMPLEX*16 array, dimension (LDA,K)
*> The i-th column must contain the vector which defines the
*> \verbatim
*> C is COMPLEX*16 array, dimension (LDC,N)
*> On entry, the M-by-N matrix C.
-*> On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
+*> On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.
*> \endverbatim
*>
*> \param[in] LDC
*> \verbatim
*> A is COMPLEX*16 array, dimension (LDA,N)
*> On entry, the M-by-N matrix A.
-*> On exit, the elements on and bleow the diagonal
+*> On exit, the elements on and below the diagonal
*> of the array contain the N-by-N lower triangular matrix L;
*> the elements above the diagonal represent Q by the rows
*> of blocked V (see Further Details).
*> \verbatim
*> IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))
*> The vector of pivot indices. Only the elements in positions
-*> K1 through K1+(K2-K1)*INCX of IPIV are accessed.
-*> IPIV(K) = L implies rows K and L are to be interchanged.
+*> K1 through K1+(K2-K1)*abs(INCX) of IPIV are accessed.
+*> IPIV(K1+(K-K1)*abs(INCX)) = L implies rows K and L are to be
+*> interchanged.
*> \endverbatim
*>
*> \param[in] INCX
*> \verbatim
*> INCX is INTEGER
-*> The increment between successive values of IPIV. If IPIV
+*> The increment between successive values of IPIV. If INCX
*> is negative, the pivots are applied in reverse order.
*> \endverbatim
*
* ..
* .. Executable Statements ..
*
-* Interchange row I with row IPIV(I) for each of rows K1 through K2.
+* Interchange row I with row IPIV(K1+(I-K1)*abs(INCX)) for each of rows
+* K1 through K2.
*
IF( INCX.GT.0 ) THEN
IX0 = K1
*> of the matrix B. NRHS >= 0.
*> \endverbatim
*>
-*> \param[in,out] A
+*> \param[in] A
*> \verbatim
*> A is COMPLEX*16 array, dimension (LDA,N)
*> Details of factors computed by ZSYTRF_AA.
*>
*> \param[in,out] A
*> \verbatim
-*> A is COMPLEX*16 array, dimension (LDA,N)
-*> On entry, the lower triangular N-by-N matrix A.
+*> A is COMPLEX*16 array, dimension (LDA,M)
+*> On entry, the lower triangular M-by-M matrix A.
*> On exit, the elements on and below the diagonal of the array
*> contain the lower triangular matrix L.
*> \endverbatim
*> \param[in] LDA
*> \verbatim
*> LDA is INTEGER
-*> The leading dimension of the array A. LDA >= max(1,N).
+*> The leading dimension of the array A. LDA >= max(1,M).
*> \endverbatim
*>
*> \param[in,out] B
*> C = [ A ] [ B ]
*>
*>
-*> where A is an lower triangular N-by-N matrix, and B is M-by-N pentagonal
+*> where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
*> matrix consisting of a M-by-(N-L) rectangular matrix B1 on left of a M-by-L
*> upper trapezoidal matrix B2:
*> [ B ] = [ B1 ] [ B2 ]
*> [ B1 ] <- M-by-(N-L) rectangular
-*> [ B2 ] <- M-by-L upper trapezoidal.
+*> [ B2 ] <- M-by-L lower trapezoidal.
*>
*> The lower trapezoidal matrix B2 consists of the first L columns of a
-*> N-by-N lower triangular matrix, where 0 <= L <= MIN(M,N). If L=0,
+*> M-by-M lower triangular matrix, where 0 <= L <= MIN(M,N). If L=0,
*> B is rectangular M-by-N; if M=L=N, B is lower triangular.
*>
*> The matrix W stores the elementary reflectors H(i) in the i-th row
*> above the diagonal (of A) in the M-by-(M+N) input matrix C
*> [ C ] = [ A ] [ B ]
-*> [ A ] <- lower triangular N-by-N
+*> [ A ] <- lower triangular M-by-M
*> [ B ] <- M-by-N pentagonal
*>
*> so that W can be represented as
*> [ W ] = [ I ] [ V ]
-*> [ I ] <- identity, N-by-N
+*> [ I ] <- identity, M-by-M
*> [ V ] <- M-by-N, same form as B.
*>
*> Thus, all of information needed for W is contained on exit in B, which
*>
*> \param[in,out] A
*> \verbatim
-*> A is COMPLEX*16 array, dimension (LDA,N)
+*> A is COMPLEX*16 array, dimension (LDA,M)
*> On entry, the lower triangular M-by-M matrix A.
*> On exit, the elements on and below the diagonal of the array
*> contain the lower triangular matrix L.
*> \param[in] LDA
*> \verbatim
*> LDA is INTEGER
-*> The leading dimension of the array A. LDA >= max(1,N).
+*> The leading dimension of the array A. LDA >= max(1,M).
*> \endverbatim
*>
*> \param[in,out] B
*> C = [ A ][ B ]
*>
*>
-*> where A is an lower triangular N-by-N matrix, and B is M-by-N pentagonal
+*> where A is an lower triangular M-by-M matrix, and B is M-by-N pentagonal
*> matrix consisting of a M-by-(N-L) rectangular matrix B1 left of a M-by-L
*> upper trapezoidal matrix B2:
*>
*> above the diagonal (of A) in the M-by-(M+N) input matrix C
*>
*> C = [ A ][ B ]
-*> [ A ] <- lower triangular N-by-N
+*> [ A ] <- lower triangular M-by-M
*> [ B ] <- M-by-N pentagonal
*>
*> so that W can be represented as
*>
*> W = [ I ][ V ]
-*> [ I ] <- identity, N-by-N
+*> [ I ] <- identity, M-by-M
*> [ V ] <- M-by-N, same form as B.
*>
*> Thus, all of information needed for W is contained on exit in B, which
* http://www.netlib.org/lapack/explore-html/
*
*> \htmlonly
-*> Download DTPMQRT + dependencies
+*> Download ZTPMLQT + dependencies
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/ztpmlqt.f">
*> [TGZ]</a>
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/ztpmlqt.f">
*>
*> \verbatim
*>
-*> ZTPMQRT applies a complex orthogonal matrix Q obtained from a
-*> "triangular-pentagonal" real block reflector H to a general
-*> real matrix C, which consists of two blocks A and B.
+*> ZTPMLQT applies a complex orthogonal matrix Q obtained from a
+*> "triangular-pentagonal" complex block reflector H to a general
+*> complex matrix C, which consists of two blocks A and B.
*> \endverbatim
*
* Arguments:
*> \param[in] SIDE
*> \verbatim
*> SIDE is CHARACTER*1
-*> = 'L': apply Q or Q**C from the Left;
-*> = 'R': apply Q or Q**C from the Right.
+*> = 'L': apply Q or Q**H from the Left;
+*> = 'R': apply Q or Q**H from the Right.
*> \endverbatim
*>
*> \param[in] TRANS
*> \verbatim
*> TRANS is CHARACTER*1
*> = 'N': No transpose, apply Q;
-*> = 'C': Transpose, apply Q**C.
+*> = 'C': Transpose, apply Q**H.
*> \endverbatim
*>
*> \param[in] M
*> (LDA,K) if SIDE = 'R'
*> On entry, the K-by-N or M-by-K matrix A.
*> On exit, A is overwritten by the corresponding block of
-*> Q*C or Q**C*C or C*Q or C*Q**C. See Further Details.
+*> Q*C or Q**H*C or C*Q or C*Q**H. See Further Details.
*> \endverbatim
*>
*> \param[in] LDA
*> B is COMPLEX*16 array, dimension (LDB,N)
*> On entry, the M-by-N matrix B.
*> On exit, B is overwritten by the corresponding block of
-*> Q*C or Q**C*C or C*Q or C*Q**C. See Further Details.
+*> Q*C or Q**H*C or C*Q or C*Q**H. See Further Details.
*> \endverbatim
*>
*> \param[in] LDB
*>
*> If TRANS='N' and SIDE='L', C is on exit replaced with Q * C.
*>
-*> If TRANS='C' and SIDE='L', C is on exit replaced with Q**C * C.
+*> If TRANS='C' and SIDE='L', C is on exit replaced with Q**H * C.
*>
*> If TRANS='N' and SIDE='R', C is on exit replaced with C * Q.
*>
-*> If TRANS='C' and SIDE='R', C is on exit replaced with C * Q**C.
+*> If TRANS='C' and SIDE='R', C is on exit replaced with C * Q**H.
*> \endverbatim
*>
* =====================================================================
EXTERNAL LSAME, ILAENV, IZAMAX, DLAMCH, DZASUM
* ..
* .. External Subroutines ..
- EXTERNAL XERBLA, ZCOPY, ZDSCAL, ZGEMV, ZLATRS
+ EXTERNAL XERBLA, ZCOPY, ZDSCAL, ZGEMV, ZLATRS,
$ ZGEMM, DLABAD, ZLASET
* ..
* .. Intrinsic Functions ..
# without any arguments creates all four test programs.
# The executable files are called
# xeigtsts, xeigtstd, xeigtstc, and xeigtstz
-# and are created in the next higher directory level.
#
# To remove the object files after the executable files have been
# created, enter
-# make clean
+# make cleanobj
# On some systems, you can force the source files to be recompiled by
# entering (for example)
# make single FRC=FRC
all: single complex double complex16
-single: ../xeigtsts
-complex: ../xeigtstc
-double: ../xeigtstd
-complex16: ../xeigtstz
+single: xeigtsts
+complex: xeigtstc
+double: xeigtstd
+complex16: xeigtstz
-../xeigtsts: $(SEIGTST) $(SCIGTST) $(AEIGTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ \
- $(SEIGTST) $(SCIGTST) $(AEIGTST) ../../$(TMGLIB) \
- ../../$(LAPACKLIB) $(BLASLIB)
+xeigtsts: $(SEIGTST) $(SCIGTST) $(AEIGTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xeigtstc: $(CEIGTST) $(SCIGTST) $(AEIGTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ \
- $(CEIGTST) $(SCIGTST) $(AEIGTST) ../../$(TMGLIB) \
- ../../$(LAPACKLIB) $(BLASLIB)
+xeigtstc: $(CEIGTST) $(SCIGTST) $(AEIGTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xeigtstd: $(DEIGTST) $(DZIGTST) $(AEIGTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ \
- $(DEIGTST) $(DZIGTST) $(AEIGTST) ../../$(TMGLIB) \
- ../../$(LAPACKLIB) $(BLASLIB)
+xeigtstd: $(DEIGTST) $(DZIGTST) $(AEIGTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xeigtstz: $(ZEIGTST) $(DZIGTST) $(AEIGTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ \
- $(ZEIGTST) $(DZIGTST) $(AEIGTST) ../../$(TMGLIB) \
- ../../$(LAPACKLIB) $(BLASLIB)
+xeigtstz: $(ZEIGTST) $(DZIGTST) $(AEIGTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
$(AEIGTST): $(FRC)
$(SCIGTST): $(FRC)
FRC:
@FRC=$(FRC)
-clean:
+clean: cleanobj cleanexe
+cleanobj:
rm -f *.o
+cleanexe:
+ rm -f xeigtst*
schkee.o: schkee.f
$(FORTRAN) $(DRVOPTS) -c -o $@ $<
* ..
* .. External Subroutines ..
EXTERNAL DLASUM, XERBLA, ZHBT21, ZHBTRD, ZLACPY, ZLASET,
- $ ZLATMR, ZLATMS, ZHBTRD_HB2ST, ZSTEQR
+ $ ZLATMR, ZLATMS, ZHETRD_HB2ST, ZSTEQR
* ..
* .. Intrinsic Functions ..
INTRINSIC ABS, DBLE, DCONJG, MAX, MIN, SQRT
$ ZHET22, ZHPEV, ZHPEVD, ZHPEVX, ZLACPY, ZLASET,
$ ZHEEVD_2STAGE, ZHEEVR_2STAGE, ZHEEVX_2STAGE,
$ ZHEEV_2STAGE, ZHBEV_2STAGE, ZHBEVD_2STAGE,
- $ ZHBEVX_2STAGE, ZHETRD_2STAGE, ZHETRD_SY2SB,
- $ ZHETRD_SB2ST, ZLATMR, ZLATMS
+ $ ZHBEVX_2STAGE, ZHETRD_2STAGE, ZLATMR, ZLATMS
* ..
* .. Intrinsic Functions ..
INTRINSIC ABS, DBLE, INT, LOG, MAX, MIN, SQRT
*> ZHPEV, CHPEVX, CHPEVD, and ZSTEDC.
*> ZHEEVD_2STAGE, ZHEEVR_2STAGE, ZHEEVX_2STAGE,
*> ZHEEV_2STAGE, ZHBEV_2STAGE, ZHBEVD_2STAGE,
-*> ZHBEVX_2STAGE, ZHETRD_2STAGE, ZHETRD_SY2SB,
-*> ZHETRD_SB2ST
+*> ZHBEVX_2STAGE, ZHETRD_2STAGE
*> \endverbatim
*
* Arguments:
$ ZUNGTR, ZUNMTR, ZUPGTR, ZUPMTR,
$ ZHEEVD_2STAGE, ZHEEVR_2STAGE, ZHEEVX_2STAGE,
$ ZHEEV_2STAGE, ZHBEV_2STAGE, ZHBEVD_2STAGE,
- $ ZHBEVX_2STAGE, ZHETRD_2STAGE, ZHETRD_SY2SB,
- $ ZHETRD_SB2ST
+ $ ZHBEVX_2STAGE, ZHETRD_2STAGE
* ..
* .. Scalars in Common ..
LOGICAL LERR, OK
# ALINTST -- Auxiliary test routines
# SLINTST -- Single precision real test routines
# CLINTST -- Single precision complex test routines
-# SCLNTST -- Single and Complex routines in common
+# SCLNTST -- Single precision real and complex routines in common
# DLINTST -- Double precision real test routines
# ZLINTST -- Double precision complex test routines
-# DZLNTST -- Double and Double Complex routines in common
+# DZLNTST -- Double precision real and complex routines in common
#
# Test programs can be generated for all or some of the four different
# precisions. Enter make followed by one or more of the data types
# make
# without any arguments creates all four test programs.
# The executable files are called
-# xlintims, xlintimd, xlintimc, and xlintimz
-# and are created in the next higher directory level.
+# xlintsts, xlintstd, xlintstc, and xlintstz
#
# To remove the object files after the executable files have been
# created, enter
-# make clean
+# make cleanobj
# On some systems, you can force the source files to be recompiled by
# entering (for example)
# make single FRC=FRC
all: single double complex complex16 proto-single proto-double proto-complex proto-complex16
-single: ../xlintsts
-double: ../xlintstd
-complex: ../xlintstc
-complex16: ../xlintstz
+single: xlintsts
+double: xlintstd
+complex: xlintstc
+complex16: xlintstz
-proto-single: ../xlintstrfs
-proto-double: ../xlintstds ../xlintstrfd
-proto-complex: ../xlintstrfc
-proto-complex16: ../xlintstzc ../xlintstrfz
+proto-single: xlintstrfs
+proto-double: xlintstds xlintstrfd
+proto-complex: xlintstrfc
+proto-complex16: xlintstzc xlintstrfz
-../xlintsts: $(ALINTST) $(SLINTST) $(SCLNTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(ALINTST) $(SCLNTST) $(SLINTST) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(XBLASLIB) $(BLASLIB)
+xlintsts: $(ALINTST) $(SLINTST) $(SCLNTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(XBLASLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstc: $(ALINTST) $(CLINTST) $(SCLNTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(ALINTST) $(SCLNTST) $(CLINTST) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(XBLASLIB) $(BLASLIB)
+xlintstc: $(ALINTST) $(CLINTST) $(SCLNTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(XBLASLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstd: $(ALINTST) $(DLINTST) $(DZLNTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $^ \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(XBLASLIB) $(BLASLIB)
+xlintstd: $(ALINTST) $(DLINTST) $(DZLNTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(XBLASLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstz: $(ALINTST) $(ZLINTST) $(DZLNTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(ALINTST) $(DZLNTST) $(ZLINTST) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(XBLASLIB) $(BLASLIB)
+xlintstz: $(ALINTST) $(ZLINTST) $(DZLNTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(XBLASLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstds: $(DSLINTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(DSLINTST) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+xlintstds: $(DSLINTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstzc: $(ZCLINTST) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(ZCLINTST) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+xlintstzc: $(ZCLINTST) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstrfs: $(SLINTSTRFP) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(SLINTSTRFP) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+xlintstrfs: $(SLINTSTRFP) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstrfd: $(DLINTSTRFP) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(DLINTSTRFP) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+xlintstrfd: $(DLINTSTRFP) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstrfc: $(CLINTSTRFP) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(CLINTSTRFP) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+xlintstrfc: $(CLINTSTRFP) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
-../xlintstrfz: $(ZLINTSTRFP) ../../$(LAPACKLIB)
- $(LOADER) $(LOADOPTS) -o $@ $(ZLINTSTRFP) \
- ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+xlintstrfz: $(ZLINTSTRFP) ../../$(TMGLIB) ../../$(LAPACKLIB) $(BLASLIB)
+ $(LOADER) $(LOADOPTS) -o $@ $^
$(ALINTST): $(FRC)
$(SCLNTST): $(FRC)
FRC:
@FRC=$(FRC)
-clean:
+clean: cleanobj cleanexe
+cleanobj:
rm -f *.o
+cleanexe:
+ rm -f xlintst*
schkaa.o: schkaa.f
$(FORTRAN) $(DRVOPTS) -c -o $@ $<
# and is created at the LAPACK directory level.
#
# To remove the object files after the library is created, enter
-# make clean
+# make cleanobj
# On some systems, you can force the source files to be recompiled by
# entering (for example)
# make single FRC=FRC
$(DZATGEN)
../../$(TMGLIB): $(ALLOBJ)
- $(ARCH) $(ARCHFLAGS) $@ $(ALLOBJ)
+ $(ARCH) $(ARCHFLAGS) $@ $^
$(RANLIB) $@
single: $(SMATGEN) $(SCATGEN)
- $(ARCH) $(ARCHFLAGS) ../../$(TMGLIB) $(SMATGEN) $(SCATGEN)
+ $(ARCH) $(ARCHFLAGS) ../../$(TMGLIB) $^
$(RANLIB) ../../$(TMGLIB)
complex: $(CMATGEN) $(SCATGEN)
- $(ARCH) $(ARCHFLAGS) ../../$(TMGLIB) $(CMATGEN) $(SCATGEN)
+ $(ARCH) $(ARCHFLAGS) ../../$(TMGLIB) $^
$(RANLIB) ../../$(TMGLIB)
double: $(DMATGEN) $(DZATGEN)
- $(ARCH) $(ARCHFLAGS) ../../$(TMGLIB) $(DMATGEN) $(DZATGEN)
+ $(ARCH) $(ARCHFLAGS) ../../$(TMGLIB) $^
$(RANLIB) ../../$(TMGLIB)
complex16: $(ZMATGEN) $(DZATGEN)
- $(ARCH) $(ARCHFLAGS) ../../$(TMGLIB) $(ZMATGEN) $(DZATGEN)
+ $(ARCH) $(ARCHFLAGS) ../../$(TMGLIB) $^
$(RANLIB) ../../$(TMGLIB)
$(SCATGEN): $(FRC)
FRC:
@FRC=$(FRC)
-clean:
+clean: cleanobj cleanlib
+cleanobj:
rm -f *.o
+cleanlib:
+ rm -f ../../$(TMGLIB)
.f.o:
$(FORTRAN) $(OPTS) -c -o $@ $<
# The executable files are called:
# xlintsts, xlintstd, xlintstc, and xlintstz for LIN
# xeigtsts, xeigtstd, xeigtstc, and xeigtstz for EIG
-# and exist in the current directory level.
#
# To remove the output files after the tests have been run, enter
-# make clean
+# make cleantest
#
# To re-run specific tests after a make, enter (for example):
# 'rm ssvd.out; make' or:
include ../make.inc
-ifneq ($(strip $(VARLIB)),)
- LAPACKLIB := $(VARLIB) ../$(LAPACKLIB)
-endif
-
-
all: single complex double complex16 singleproto doubleproto complexproto complex16proto
SEIGTST= snep.out \
#
# ======== SINGLE LIN TESTS ===========================
-stest.out: stest.in xlintsts
+stest.out: stest.in LIN/xlintsts
@echo Testing REAL LAPACK linear equation routines
- ./xlintsts < stest.in > $@ 2>&1
+ ./LIN/xlintsts < $< > $@ 2>&1
#
# ======== COMPLEX LIN TESTS ==========================
-ctest.out: ctest.in xlintstc
+ctest.out: ctest.in LIN/xlintstc
@echo Testing COMPLEX LAPACK linear equation routines
- ./xlintstc < ctest.in > $@ 2>&1
+ ./LIN/xlintstc < $< > $@ 2>&1
#
# ======== DOUBLE LIN TESTS ===========================
-dtest.out: dtest.in xlintstd
+dtest.out: dtest.in LIN/xlintstd
@echo Testing DOUBLE PRECISION LAPACK linear equation routines
- ./xlintstd < dtest.in > $@ 2>&1
+ ./LIN/xlintstd < $< > $@ 2>&1
#
# ======== COMPLEX16 LIN TESTS ========================
-ztest.out: ztest.in xlintstz
+ztest.out: ztest.in LIN/xlintstz
@echo Testing COMPLEX16 LAPACK linear equation routines
- ./xlintstz < ztest.in > $@ 2>&1
+ ./LIN/xlintstz < $< > $@ 2>&1
#
# ======== SINGLE-DOUBLE PROTO LIN TESTS ==============
-dstest.out: dstest.in xlintstds
+dstest.out: dstest.in LIN/xlintstds
@echo Testing SINGLE-DOUBLE PRECISION LAPACK prototype linear equation routines
- ./xlintstds < dstest.in > $@ 2>&1
+ ./LIN/xlintstds < $< > $@ 2>&1
#
# ======== COMPLEX-COMPLEX16 LIN TESTS ========================
-zctest.out: zctest.in xlintstzc
+zctest.out: zctest.in LIN/xlintstzc
@echo Testing COMPLEX-COMPLEX16 LAPACK prototype linear equation routines
- ./xlintstzc < zctest.in > $@ 2>&1
+ ./LIN/xlintstzc < $< > $@ 2>&1
#
# ======== SINGLE RFP LIN TESTS ========================
-stest_rfp.out: stest_rfp.in xlintstrfs
+stest_rfp.out: stest_rfp.in LIN/xlintstrfs
@echo Testing REAL LAPACK RFP prototype linear equation routines
- ./xlintstrfs < stest_rfp.in > $@ 2>&1
+ ./LIN/xlintstrfs < $< > $@ 2>&1
#
# ======== COMPLEX16 RFP LIN TESTS ========================
-dtest_rfp.out: dtest_rfp.in xlintstrfd
+dtest_rfp.out: dtest_rfp.in LIN/xlintstrfd
@echo Testing DOUBLE PRECISION LAPACK RFP prototype linear equation routines
- ./xlintstrfd < dtest_rfp.in > $@ 2>&1
+ ./LIN/xlintstrfd < $< > $@ 2>&1
#
# ======== COMPLEX16 RFP LIN TESTS ========================
-ctest_rfp.out: ctest_rfp.in xlintstrfc
+ctest_rfp.out: ctest_rfp.in LIN/xlintstrfc
@echo Testing COMPLEX LAPACK RFP prototype linear equation routines
- ./xlintstrfc < ctest_rfp.in > $@ 2>&1
+ ./LIN/xlintstrfc < $< > $@ 2>&1
#
# ======== COMPLEX16 RFP LIN TESTS ========================
-ztest_rfp.out: ztest_rfp.in xlintstrfz
+ztest_rfp.out: ztest_rfp.in LIN/xlintstrfz
@echo Testing COMPLEX16 LAPACK RFP prototype linear equation routines
- ./xlintstrfz < ztest_rfp.in > $@ 2>&1
+ ./LIN/xlintstrfz < $< > $@ 2>&1
#
#
# ======== SINGLE EIG TESTS ===========================
#
-snep.out: nep.in xeigtsts
+snep.out: nep.in EIG/xeigtsts
@echo NEP: Testing Nonsymmetric Eigenvalue Problem routines
- ./xeigtsts < nep.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-ssep.out: sep.in xeigtsts
+ssep.out: sep.in EIG/xeigtsts
@echo SEP: Testing Symmetric Eigenvalue Problem routines
- ./xeigtsts < sep.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sse2.out: se2.in xeigtsts
+sse2.out: se2.in EIG/xeigtsts
@echo SEP: Testing Symmetric Eigenvalue Problem routines
- ./xeigtsts < se2.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-ssvd.out: svd.in xeigtsts
+ssvd.out: svd.in EIG/xeigtsts
@echo SVD: Testing Singular Value Decomposition routines
- ./xeigtsts < svd.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sec.out: sec.in xeigtsts
+sec.out: sec.in EIG/xeigtsts
@echo SEC: Testing REAL Eigen Condition Routines
- ./xeigtsts < sec.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sed.out: sed.in xeigtsts
+sed.out: sed.in EIG/xeigtsts
@echo SEV: Testing REAL Nonsymmetric Eigenvalue Driver
- ./xeigtsts < sed.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sgg.out: sgg.in xeigtsts
+sgg.out: sgg.in EIG/xeigtsts
@echo SGG: Testing REAL Nonsymmetric Generalized Eigenvalue Problem routines
- ./xeigtsts < sgg.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sgd.out: sgd.in xeigtsts
+sgd.out: sgd.in EIG/xeigtsts
@echo SGD: Testing REAL Nonsymmetric Generalized Eigenvalue Problem driver routines
- ./xeigtsts < sgd.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-ssb.out: ssb.in xeigtsts
+ssb.out: ssb.in EIG/xeigtsts
@echo SSB: Testing REAL Symmetric Eigenvalue Problem routines
- ./xeigtsts < ssb.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-ssg.out: ssg.in xeigtsts
+ssg.out: ssg.in EIG/xeigtsts
@echo SSG: Testing REAL Symmetric Generalized Eigenvalue Problem routines
- ./xeigtsts < ssg.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sbal.out: sbal.in xeigtsts
+sbal.out: sbal.in EIG/xeigtsts
@echo SGEBAL: Testing the balancing of a REAL general matrix
- ./xeigtsts < sbal.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sbak.out: sbak.in xeigtsts
+sbak.out: sbak.in EIG/xeigtsts
@echo SGEBAK: Testing the back transformation of a REAL balanced matrix
- ./xeigtsts < sbak.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sgbal.out: sgbal.in xeigtsts
+sgbal.out: sgbal.in EIG/xeigtsts
@echo SGGBAL: Testing the balancing of a pair of REAL general matrices
- ./xeigtsts < sgbal.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sgbak.out: sgbak.in xeigtsts
+sgbak.out: sgbak.in EIG/xeigtsts
@echo SGGBAK: Testing the back transformation of a pair of REAL balanced matrices
- ./xeigtsts < sgbak.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sbb.out: sbb.in xeigtsts
+sbb.out: sbb.in EIG/xeigtsts
@echo SBB: Testing banded Singular Value Decomposition routines
- ./xeigtsts < sbb.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sglm.out: glm.in xeigtsts
+sglm.out: glm.in EIG/xeigtsts
@echo GLM: Testing Generalized Linear Regression Model routines
- ./xeigtsts < glm.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sgqr.out: gqr.in xeigtsts
+sgqr.out: gqr.in EIG/xeigtsts
@echo GQR: Testing Generalized QR and RQ factorization routines
- ./xeigtsts < gqr.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-sgsv.out: gsv.in xeigtsts
+sgsv.out: gsv.in EIG/xeigtsts
@echo GSV: Testing Generalized Singular Value Decomposition routines
- ./xeigtsts < gsv.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-scsd.out: csd.in xeigtsts
+scsd.out: csd.in EIG/xeigtsts
@echo CSD: Testing CS Decomposition routines
- ./xeigtsts < csd.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
-slse.out: lse.in xeigtsts
+slse.out: lse.in EIG/xeigtsts
@echo LSE: Testing Constrained Linear Least Squares routines
- ./xeigtsts < lse.in > $@ 2>&1
+ ./EIG/xeigtsts < $< > $@ 2>&1
#
# ======== COMPLEX EIG TESTS ===========================
-cnep.out: nep.in xeigtstc
+cnep.out: nep.in EIG/xeigtstc
@echo NEP: Testing Nonsymmetric Eigenvalue Problem routines
- ./xeigtstc < nep.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-csep.out: sep.in xeigtstc
+csep.out: sep.in EIG/xeigtstc
@echo SEP: Testing Symmetric Eigenvalue Problem routines
- ./xeigtstc < sep.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cse2.out: se2.in xeigtstc
+cse2.out: se2.in EIG/xeigtstc
@echo SEP: Testing Symmetric Eigenvalue Problem routines
- ./xeigtstc < se2.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-csvd.out: svd.in xeigtstc
+csvd.out: svd.in EIG/xeigtstc
@echo SVD: Testing Singular Value Decomposition routines
- ./xeigtstc < svd.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cec.out: cec.in xeigtstc
+cec.out: cec.in EIG/xeigtstc
@echo CEC: Testing COMPLEX Eigen Condition Routines
- ./xeigtstc < cec.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-ced.out: ced.in xeigtstc
+ced.out: ced.in EIG/xeigtstc
@echo CES: Testing COMPLEX Nonsymmetric Schur Form Driver
- ./xeigtstc < ced.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cgg.out: cgg.in xeigtstc
+cgg.out: cgg.in EIG/xeigtstc
@echo CGG: Testing COMPLEX Nonsymmetric Generalized Eigenvalue Problem routines
- ./xeigtstc < cgg.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cgd.out: cgd.in xeigtstc
+cgd.out: cgd.in EIG/xeigtstc
@echo CGD: Testing COMPLEX Nonsymmetric Generalized Eigenvalue Problem driver routines
- ./xeigtstc < cgd.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-csb.out: csb.in xeigtstc
+csb.out: csb.in EIG/xeigtstc
@echo CHB: Testing Hermitian Eigenvalue Problem routines
- ./xeigtstc < csb.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-csg.out: csg.in xeigtstc
+csg.out: csg.in EIG/xeigtstc
@echo CSG: Testing Symmetric Generalized Eigenvalue Problem routines
- ./xeigtstc < csg.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cbal.out: cbal.in xeigtstc
+cbal.out: cbal.in EIG/xeigtstc
@echo CGEBAL: Testing the balancing of a COMPLEX general matrix
- ./xeigtstc < cbal.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cbak.out: cbak.in xeigtstc
+cbak.out: cbak.in EIG/xeigtstc
@echo CGEBAK: Testing the back transformation of a COMPLEX balanced matrix
- ./xeigtstc < cbak.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cgbal.out: cgbal.in xeigtstc
+cgbal.out: cgbal.in EIG/xeigtstc
@echo CGGBAL: Testing the balancing of a pair of COMPLEX general matrices
- ./xeigtstc < cgbal.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cgbak.out: cgbak.in xeigtstc
+cgbak.out: cgbak.in EIG/xeigtstc
@echo CGGBAK: Testing the back transformation of a pair of COMPLEX balanced matrices
- ./xeigtstc < cgbak.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cbb.out: cbb.in xeigtstc
+cbb.out: cbb.in EIG/xeigtstc
@echo CBB: Testing banded Singular Value Decomposition routines
- ./xeigtstc < cbb.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cglm.out: glm.in xeigtstc
+cglm.out: glm.in EIG/xeigtstc
@echo GLM: Testing Generalized Linear Regression Model routines
- ./xeigtstc < glm.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cgqr.out: gqr.in xeigtstc
+cgqr.out: gqr.in EIG/xeigtstc
@echo GQR: Testing Generalized QR and RQ factorization routines
- ./xeigtstc < gqr.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-cgsv.out: gsv.in xeigtstc
+cgsv.out: gsv.in EIG/xeigtstc
@echo GSV: Testing Generalized Singular Value Decomposition routines
- ./xeigtstc < gsv.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-ccsd.out: csd.in xeigtstc
+ccsd.out: csd.in EIG/xeigtstc
@echo CSD: Testing CS Decomposition routines
- ./xeigtstc < csd.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
-clse.out: lse.in xeigtstc
+clse.out: lse.in EIG/xeigtstc
@echo LSE: Testing Constrained Linear Least Squares routines
- ./xeigtstc < lse.in > $@ 2>&1
+ ./EIG/xeigtstc < $< > $@ 2>&1
#
# ======== DOUBLE EIG TESTS ===========================
-dnep.out: nep.in xeigtstd
+dnep.out: nep.in EIG/xeigtstd
@echo NEP: Testing Nonsymmetric Eigenvalue Problem routines
- ./xeigtstd < nep.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dsep.out: sep.in xeigtstd
+dsep.out: sep.in EIG/xeigtstd
@echo SEP: Testing Symmetric Eigenvalue Problem routines
- ./xeigtstd < sep.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dse2.out: se2.in xeigtstd
+dse2.out: se2.in EIG/xeigtstd
@echo SEP: Testing Symmetric Eigenvalue Problem routines
- ./xeigtstd < se2.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dsvd.out: svd.in xeigtstd
+dsvd.out: svd.in EIG/xeigtstd
@echo SVD: Testing Singular Value Decomposition routines
- ./xeigtstd < svd.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dec.out: dec.in xeigtstd
+dec.out: dec.in EIG/xeigtstd
@echo DEC: Testing DOUBLE PRECISION Eigen Condition Routines
- ./xeigtstd < dec.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-ded.out: ded.in xeigtstd
+ded.out: ded.in EIG/xeigtstd
@echo DEV: Testing DOUBLE PRECISION Nonsymmetric Eigenvalue Driver
- ./xeigtstd < ded.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dgg.out: dgg.in xeigtstd
+dgg.out: dgg.in EIG/xeigtstd
@echo DGG: Testing DOUBLE PRECISION Nonsymmetric Generalized Eigenvalue Problem routines
- ./xeigtstd < dgg.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dgd.out: dgd.in xeigtstd
+dgd.out: dgd.in EIG/xeigtstd
@echo DGD: Testing DOUBLE PRECISION Nonsymmetric Generalized Eigenvalue Problem driver routines
- ./xeigtstd < dgd.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dsb.out: dsb.in xeigtstd
+dsb.out: dsb.in EIG/xeigtstd
@echo DSB: Testing DOUBLE PRECISION Symmetric Eigenvalue Problem routines
- ./xeigtstd < dsb.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dsg.out: dsg.in xeigtstd
+dsg.out: dsg.in EIG/xeigtstd
@echo DSG: Testing DOUBLE PRECISION Symmetric Generalized Eigenvalue Problem routines
- ./xeigtstd < dsg.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dbal.out: dbal.in xeigtstd
+dbal.out: dbal.in EIG/xeigtstd
@echo DGEBAL: Testing the balancing of a DOUBLE PRECISION general matrix
- ./xeigtstd < dbal.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dbak.out: dbak.in xeigtstd
+dbak.out: dbak.in EIG/xeigtstd
@echo DGEBAK: Testing the back transformation of a DOUBLE PRECISION balanced matrix
- ./xeigtstd < dbak.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dgbal.out: dgbal.in xeigtstd
+dgbal.out: dgbal.in EIG/xeigtstd
@echo DGGBAL: Testing the balancing of a pair of DOUBLE PRECISION general matrices
- ./xeigtstd < dgbal.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dgbak.out: dgbak.in xeigtstd
+dgbak.out: dgbak.in EIG/xeigtstd
@echo DGGBAK: Testing the back transformation of a pair of DOUBLE PRECISION balanced matrices
- ./xeigtstd < dgbak.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dbb.out: dbb.in xeigtstd
+dbb.out: dbb.in EIG/xeigtstd
@echo DBB: Testing banded Singular Value Decomposition routines
- ./xeigtstd < dbb.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dglm.out: glm.in xeigtstd
+dglm.out: glm.in EIG/xeigtstd
@echo GLM: Testing Generalized Linear Regression Model routines
- ./xeigtstd < glm.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dgqr.out: gqr.in xeigtstd
+dgqr.out: gqr.in EIG/xeigtstd
@echo GQR: Testing Generalized QR and RQ factorization routines
- ./xeigtstd < gqr.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dgsv.out: gsv.in xeigtstd
+dgsv.out: gsv.in EIG/xeigtstd
@echo GSV: Testing Generalized Singular Value Decomposition routines
- ./xeigtstd < gsv.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dcsd.out: csd.in xeigtstd
+dcsd.out: csd.in EIG/xeigtstd
@echo CSD: Testing CS Decomposition routines
- ./xeigtstd < csd.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
-dlse.out: lse.in xeigtstd
+dlse.out: lse.in EIG/xeigtstd
@echo LSE: Testing Constrained Linear Least Squares routines
- ./xeigtstd < lse.in > $@ 2>&1
+ ./EIG/xeigtstd < $< > $@ 2>&1
#
# ======== COMPLEX16 EIG TESTS ===========================
-znep.out: nep.in xeigtstz
+znep.out: nep.in EIG/xeigtstz
@echo NEP: Testing Nonsymmetric Eigenvalue Problem routines
- ./xeigtstz < nep.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zsep.out: sep.in xeigtstz
+zsep.out: sep.in EIG/xeigtstz
@echo SEP: Testing Symmetric Eigenvalue Problem routines
- ./xeigtstz < sep.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zse2.out: se2.in xeigtstz
+zse2.out: se2.in EIG/xeigtstz
@echo SEP: Testing Symmetric Eigenvalue Problem routines
- ./xeigtstz < se2.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zsvd.out: svd.in xeigtstz
+zsvd.out: svd.in EIG/xeigtstz
@echo SVD: Testing Singular Value Decomposition routines
- ./xeigtstz < svd.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zec.out: zec.in xeigtstz
+zec.out: zec.in EIG/xeigtstz
@echo ZEC: Testing COMPLEX16 Eigen Condition Routines
- ./xeigtstz < zec.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zed.out: zed.in xeigtstz
+zed.out: zed.in EIG/xeigtstz
@echo ZES: Testing COMPLEX16 Nonsymmetric Schur Form Driver
- ./xeigtstz < zed.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zgg.out: zgg.in xeigtstz
+zgg.out: zgg.in EIG/xeigtstz
@echo ZGG: Testing COMPLEX16 Nonsymmetric Generalized Eigenvalue Problem routines
- ./xeigtstz < zgg.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zgd.out: zgd.in xeigtstz
+zgd.out: zgd.in EIG/xeigtstz
@echo ZGD: Testing COMPLEX16 Nonsymmetric Generalized Eigenvalue Problem driver routines
- ./xeigtstz < zgd.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zsb.out: zsb.in xeigtstz
+zsb.out: zsb.in EIG/xeigtstz
@echo ZHB: Testing Hermitian Eigenvalue Problem routines
- ./xeigtstz < zsb.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zsg.out: zsg.in xeigtstz
+zsg.out: zsg.in EIG/xeigtstz
@echo ZSG: Testing Symmetric Generalized Eigenvalue Problem routines
- ./xeigtstz < zsg.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zbal.out: zbal.in xeigtstz
+zbal.out: zbal.in EIG/xeigtstz
@echo ZGEBAL: Testing the balancing of a COMPLEX16 general matrix
- ./xeigtstz < zbal.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zbak.out: zbak.in xeigtstz
+zbak.out: zbak.in EIG/xeigtstz
@echo ZGEBAK: Testing the back transformation of a COMPLEX16 balanced matrix
- ./xeigtstz < zbak.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zgbal.out: zgbal.in xeigtstz
+zgbal.out: zgbal.in EIG/xeigtstz
@echo ZGGBAL: Testing the balancing of a pair of COMPLEX general matrices
- ./xeigtstz < zgbal.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zgbak.out: zgbak.in xeigtstz
+zgbak.out: zgbak.in EIG/xeigtstz
@echo ZGGBAK: Testing the back transformation of a pair of COMPLEX16 balanced matrices
- ./xeigtstz < zgbak.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zbb.out: zbb.in xeigtstz
+zbb.out: zbb.in EIG/xeigtstz
@echo ZBB: Testing banded Singular Value Decomposition routines
- ./xeigtstz < zbb.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zglm.out: glm.in xeigtstz
+zglm.out: glm.in EIG/xeigtstz
@echo GLM: Testing Generalized Linear Regression Model routines
- ./xeigtstz < glm.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zgqr.out: gqr.in xeigtstz
+zgqr.out: gqr.in EIG/xeigtstz
@echo GQR: Testing Generalized QR and RQ factorization routines
- ./xeigtstz < gqr.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zgsv.out: gsv.in xeigtstz
+zgsv.out: gsv.in EIG/xeigtstz
@echo GSV: Testing Generalized Singular Value Decomposition routines
- ./xeigtstz < gsv.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zcsd.out: csd.in xeigtstz
+zcsd.out: csd.in EIG/xeigtstz
@echo CSD: Testing CS Decomposition routines
- ./xeigtstz < csd.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
-zlse.out: lse.in xeigtstz
+zlse.out: lse.in EIG/xeigtstz
@echo LSE: Testing Constrained Linear Least Squares routines
- ./xeigtstz < lse.in > $@ 2>&1
+ ./EIG/xeigtstz < $< > $@ 2>&1
# ==============================================================================
-xlintsts: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) single
+LIN/xlintsts: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintsts
-xlintstc: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) complex
+LIN/xlintstc: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstc
-xlintstd: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) double
+LIN/xlintstd: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstd
-xlintstz: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) complex16
+LIN/xlintstz: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstz
-xlintstrfs: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) proto-single
+LIN/xlintstrfs: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstrfs
-xlintstrfc: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) proto-complex
+LIN/xlintstrfc: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstrfc
-xlintstrfd: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) proto-double
+LIN/xlintstrfd: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstrfd
-xlintstrfz: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) proto-complex16
+LIN/xlintstrfz: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstrfz
-xlintstds: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) proto-double
+LIN/xlintstds: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstds
-xlintstzc: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCLIN) $(FRC)
- cd LIN ; $(MAKE) proto-complex16
+LIN/xlintstzc: $(FRCLIN) $(FRC)
+ $(MAKE) -C LIN xlintstzc
-xeigtsts: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCEIG) $(FRC)
- cd EIG ; $(MAKE) single
+EIG/xeigtsts: $(FRCEIG) $(FRC)
+ $(MAKE) -C EIG xeigtsts
-xeigtstc: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCEIG) $(FRC)
- cd EIG ; $(MAKE) complex
+EIG/xeigtstc: $(FRCEIG) $(FRC)
+ $(MAKE) -C EIG xeigtstc
-xeigtstd: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCEIG) $(FRC)
- cd EIG ; $(MAKE) double
+EIG/xeigtstd: $(FRCEIG) $(FRC)
+ $(MAKE) -C EIG xeigtstd
-xeigtstz: ../$(LAPACKLIB) ../$(TMGLIB) $(FRCEIG) $(FRC)
- cd EIG ; $(MAKE) complex16
+EIG/xeigtstz: $(FRCEIG) $(FRC)
+ $(MAKE) -C EIG xeigtstz
-clean:
+clean: cleantest
+cleantest:
rm -f *.out core
-cleanup:
- rm -f x* *.out core
-
FRCLIN:
@FRCLIN=$(FRCLIN)
projects / platform / upstream / lapack.git / commitdiff