Linux man pages: Z

z80asm(1)

assembler for Z80 microprocessor

z80dasm(1)

Z80 assembly generating disassembler

zabbix_agentd(8)

Zabbix agent daemon

zabbix_get(1)

Zabbix get utility

zabbix_proxy(8)

Zabbix proxy daemon

zabbix_selinux(8)

Security Enhanced Policy for zabbix processes

zabbix_sender(1)

Zabbix sender utility

zabbix_server(8)

Zabbix server daemon

zanata_language_list(1)

supported languages of Zanata server

zanata_pom_xml_make(1)

Make pom.xml for using Zanata

zanata_zanata_xml_make(1)

Make zanata.xml for using Zanata

zapping(1)

Gnome TV/Teletext viewer

zapping_remote(1)

sends commands to running instance of Zapping

zapping_setup_fb(1)

prepares V4L/V4L2 driver for overlay

zarafa(1)

Zarafa server overview

zarafa-admin(1)

Manages Zarafa users/stores

zarafa-archiver(1)

Manages zarafa archives/performs archive operation

zarafa-archiver.cfg(5)

Zarafa archiver config file

zarafa-autorespond(1)

Vacation message response script

zarafa-dagent(1)

Deliver mails to Zarafa

zarafa-dagent.cfg(5)

Zarafa dagent config file

zarafa-fsck(1)

Start Zarafa fsck calendar check program

zarafa-gateway(1)

Start Zarafa IMAP/POP3 Gateway

zarafa-gateway.cfg(5)

Zarafa gateway config file

zarafa-ical(1)

Start Zarafa ICal/CalDAV gateway

zarafa-ical.cfg(5)

Zarafa iCal/CalDAV gateway config file

zarafa-indexer(1)

Zarafa Indexer Service

zarafa-indexer.cfg(5)

Zarafa Indexer config file

zarafa-ldap.cfg(5)

Zarafa LDAP config file

zarafa-monitor(1)

Start Zarafa monitor

zarafa-monitor.cfg(5)

Zarafa monitor config file

zarafa-passwd(1)

Change Zarafa user password

zarafa-server(1)

Start Zarafa storage server

zarafa-server.cfg(5)

Zarafa config file

zarafa-spooler(1)

Start Zarafa spooler

zarafa-spooler.cfg(5)

Zarafa spooler config file

zarafa-stats(1)

Dump zarafa statistics tables

zarafa-unix.cfg(5)

Zarafa Unix user plugin config file

zarafa_deliver_selinux(8)

Security Enhanced Policy for zarafa_deliver processes

zarafa_gateway_selinux(8)

Security Enhanced Policy for zarafa_gateway processes

zarafa_ical_selinux(8)

Security Enhanced Policy for zarafa_ical processes

zarafa_indexer_selinux(8)

Security Enhanced Policy for zarafa_indexer processes

zarafa_monitor_selinux(8)

Security Enhanced Policy for zarafa_monitor processes

zarafa_selinux(8)

Security Enhanced Policy for zarafa processes

zarafa_server_selinux(8)

Security Enhanced Policy for zarafa_server processes

zarafa_spooler_selinux(8)

Security Enhanced Policy for zarafa_spooler processes

zaxpy(l)

ZAXPY constant times vector plus vector

zbarcam(1)

scan/decode bar codes from video device

zbarimg(1)

scan/decode bar codes from image file

zbdsqr(l)

computes singular values and, , right/left singular vectors from singular value decomposition of real N-by-N bidiagonal matrix B using implicit zero-shift QR ...

zbuffer(3)

Stores 3d zbuffer info. Allegro game programming library

zcat(1)

compress/expand files

zcav(8)

test raw hard drive throughput

zcgesv(l)

computes solution to complex system of linear equations * X = B

zclock(7)

millisecond clocks/delays

zcmp(1)

compare compressed files

zcopy(l)

ZCOPY copie vector, x, to vector, y

zcposv(l)

computes solution to complex system of linear equations * X = B

zctx(7)

working with 0MQ contexts

zdb(8)

ZFS debugger

zdiff(1)

compare compressed files

zdotc(l)

forms dot product of vector

zdotu(l)

ZDOTU form dot product of two vectors

zdrot(l)

plane rotation, where cos and sin are real and vectors cx and cy are complex

zdrscl(l)

multiplies n-element complex vector x by real scalar 1/

zdscal(l)

ZDSCAL scale vector by constant

zdump(8)

timezone dumper

zebra(8)

routing manager for use with associated Quagga components

zebra_selinux(8)

Security Enhanced Policy for zebra processes

zeisstopnm(1)

convert Zeiss confocal file to PNM

zenity(1)

GTK+ dialogs

zenmap(1)

Graphical Nmap frontend/results viewer

zero(4)

data sink

zfile(7)

helper functions for working with files

zforce(1)

force '.gz' extension on all gzip files

zframe(7)

working with single message frames

zfs(8)

configures ZFS file systems

zfs-fuse(8)

ZFS filesystem daemon

zftp(1)

transfer ZEBRA formatted files over network

zgbbrd(l)

reduces complex general m-by-n band matrix to real upper bidiagonal form B by unitary transformation

zgbcon(l)

estimates reciprocal of condition number of complex general band matrix , in either 1-norm or infinity-norm

zgbequ(l)

computes row/column scalings intended to equilibrate M-by-N band matrix/reduce its condition number

zgbequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

zgbmv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y, or y := alpha*conjg*x + beta*y

zgbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is banded, and provides error bounds and backward error estimates for solution

zgbrfsx(l)

ZGBRFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

zgbsv(l)

computes solution to complex system of linear equations * X = B, where is band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are ...

zgbsvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B, **T * X = B, or **H * X = B

zgbsvxx(l)

ZGBSVXX use LU factorization to compute solution to complex*16 system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS matrices

zgbtf2(l)

computes LU factorization of complex m-by-n band matrix using partial pivoting with row interchanges

zgbtrf(l)

computes LU factorization of complex m-by-n band matrix using partial pivoting with row interchanges

zgbtrs(l)

solves system of linear equations * X = B, **T * X = B, or **H * X = B with general band matrix using LU factorization computed by ZGBTRF

zgebak(l)

forms right/left eigenvectors of complex general matrix by backward transformation on computed eigenvectors of balanced matrix output by ZGEBAL

zgebal(l)

balances general complex matrix

zgebd2(l)

reduces complex general m by n matrix to upper/lower real bidiagonal form B by unitary transformation

zgebrd(l)

reduces general complex M-by-N matrix to upper/lower bidiagonal form B by unitary transformation

zgecon(l)

estimates reciprocal of condition number of general complex matrix , in either 1-norm or infinity-norm, using LU factorization computed by ZGETRF

zgeequ(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

zgeequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

zgees(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues, Schur form T, and, , matrix of Schur vectors Z

zgeesx(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues, Schur form T, and, , matrix of Schur vectors Z

zgeev(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

zgeevx(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

zgegs(l)

routine i deprecated/has been replaced by routine ZGGES

zgegv(l)

routine i deprecated/has been replaced by routine ZGGEV

zgehd2(l)

reduces complex general matrix to upper Hessenberg form H by unitary similarity transformation

zgehrd(l)

reduces complex general matrix to upper Hessenberg form H by unitary similarity transformation

zgelq2(l)

computes LQ factorization of complex m by n matrix

zgelqf(l)

computes LQ factorization of complex M-by-N matrix

zgels(l)

solves overdetermined or underdetermined complex linear systems involving M-by-N matrix , or its conjugate-transpose, using QR or LQ factorization of

zgelsd(l)

computes minimum-norm solution to real linear least squares problem

zgelss(l)

computes minimum norm solution to complex linear least squares problem

zgelsx(l)

routine i deprecated/has been replaced by routine ZGELSY

zgelsy(l)

computes minimum-norm solution to complex linear least squares problem

zgemm(l)

performs one of matrix-matrix operations C := alpha*op*op + beta*C

zgemv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y, or y := alpha*conjg*x + beta*y

zgeql2(l)

computes QL factorization of complex m by n matrix

zgeqlf(l)

computes QL factorization of complex M-by-N matrix

zgeqp3(l)

computes QR factorization with column pivoting of matrix

zgeqpf(l)

routine i deprecated/has been replaced by routine ZGEQP3

zgeqr2(l)

computes QR factorization of complex m by n matrix

zgeqrf(l)

computes QR factorization of complex M-by-N matrix

zgerc(l)

performs rank 1 operation := alpha*x*conjg +

zgerfs(l)

improves computed solution to system of linear equations/provides error bounds/backward error estimates for solution

zgerfsx(l)

ZGERFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

zgerq2(l)

computes RQ factorization of complex m by n matrix

zgerqf(l)

computes RQ factorization of complex M-by-N matrix

zgeru(l)

performs rank 1 operation := alpha*x*y' +

zgesc2(l)

solves system of linear equations * X = scale* RHS with general N-by-N matrix using LU factorization with complete pivoting computed by ZGETC2

zgesdd(l)

computes singular value decomposition of complex M-by-N matrix , computing left/right singular vectors, by using divide-and-conquer method

zgesv(l)

computes solution to complex system of linear equations * X = B

zgesvd(l)

computes singular value decomposition of complex M-by-N matrix , computing left/right singular vectors

zgesvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B

zgesvxx(l)

ZGESVXX use LU factorization to compute solution to complex*16 system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS matrices

zgetc2(l)

computes LU factorization, using complete pivoting, of n-by-n matrix

zgetf2(l)

computes LU factorization of general m-by-n matrix using partial pivoting with row interchanges

zgetrf(l)

computes LU factorization of general M-by-N matrix using partial pivoting with row interchanges

zgetri(l)

computes inverse of matrix using LU factorization computed by ZGETRF

zgetrs(l)

solves system of linear equations * X = B, **T * X = B, or **H * X = B with general N-by-N matrix using LU factorization computed by ZGETRF

zggbak(l)

forms right or left eigenvectors of complex generalized eigenvalue problem *x = lambda*B*x, by backward transformation on computed eigenvectors of balanced ...

zggbal(l)

balances pair of general complex matrices

zgges(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, generalized complex Schur form , and left/right Schur vectors

zggesx(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, complex Schur form

zggev(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, and , left/right generalized eigenvectors

zggevx(l)

computes for pair of N-by-N complex nonsymmetric matrices generalized eigenvalues, and , left/right generalized eigenvectors

zggglm(l)

solves general Gauss-Markov linear model problem

zgghrd(l)

reduces pair of complex matrices to generalized upper Hessenberg form using unitary transformations, where is general matrix and B is upper triangular

zgglse(l)

solves linear equality-constrained least squares problem

zggqrf(l)

computes generalized QR factorization of N-by-M matrix/N-by-P matrix B

zggrqf(l)

computes generalized RQ factorization of M-by-N matrix/P-by-N matrix B

zggsvd(l)

computes generalized singular value decomposition of M-by-N complex matrix/P-by-N complex matrix B

zggsvp(l)

computes unitary matrices U, V and Q such that N-K-L K L U'**Q = K if M-K-L >= 0

zgrep(1)

search possibly compressed files for regex

zgtcon(l)

estimates reciprocal of condition number of complex tridiagonal matrix using LU factorization as computed by ZGTTRF

zgtrfs(l)

improves computed solution to system of linear equations when coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for ...

zgtsv(l)

solves equation *X = B

zgtsvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B, **T * X = B, or **H * X = B

zgttrf(l)

computes LU factorization of complex tridiagonal matrix using elimination with partial pivoting/row interchanges

zgttrs(l)

solves one of systems of equations * X = B, **T * X = B, or **H * X = B

zgtts2(l)

solves one of systems of equations * X = B, **T * X = B, or **H * X = B

zhash(7)

generic type-free hash container

zhbev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian band matrix

zhbevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian band matrix

zhbevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian band matrix

zhbgst(l)

reduces complex Hermitian-definite banded generalized eigenproblem *x = lambda*B*x to standard form C*y = lambda*y

zhbgv(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

zhbgvd(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

zhbgvx(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

zhbmv(l)

performs matrix-vector operation y := alpha**x + beta*y

zhbtrd(l)

reduces complex Hermitian band matrix to real symmetric tridiagonal form T by unitary similarity transformation

zhecon(l)

estimates reciprocal of condition number of complex Hermitian matrix using factorization = U*D*U**H/= L*D*L**H computed by ZHETRF

zheequb(l)

computes row/column scalings intended to equilibrate symmetric matrix/reduce its condition number

zheev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix

zheevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix

zheevr(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix

zheevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix

zhegs2(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form

zhegst(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form

zhegv(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhegvd(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhegvx(l)

computes selected eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhemm(l)

performs one of matrix-matrix operations C := alpha**B + beta*C

zhemv(l)

performs matrix-vector operation y := alpha**x + beta*y

zher(l)

performs hermitian rank 1 operation := alpha*x*conjg +

zher2(l)

performs hermitian rank 2 operation := alpha*x*conjg + conjg*y*conjg +

zher2k(l)

performs one of hermitian rank 2k operations C := alpha**conjg + conjg*B*conjg + beta*C

zherfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian indefinite, and provides error bounds and backward error ...

zherfsx(l)

ZHERFSX improve computed solution to system of linear equations when coefficient matrix is Hermitian indefinite, and provides error bounds and backward error ...

zherk(l)

performs one of hermitian rank k operations C := alpha**conjg + beta*C

zhesv(l)

computes solution to complex system of linear equations * X = B

zhesvx(l)

uses diagonal pivoting factorization to compute solution to complex system of linear equations * X = B

zhesvxx(l)

ZHESVXX use diagonal pivoting factorization to compute solution to complex*16 system of linear equations * X = B, where is N-by-N symmetric matrix and X and B ...

zhetd2(l)

reduces complex Hermitian matrix to real symmetric tridiagonal form T by unitary similarity transformation

zhetf2(l)

computes factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

zhetrd(l)

reduces complex Hermitian matrix to real symmetric tridiagonal form T by unitary similarity transformation

zhetrf(l)

computes factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

zhetri(l)

computes inverse of complex Hermitian indefinite matrix using factorization = U*D*U**H/= L*D*L**H computed by ZHETRF

zhetrs(l)

solves system of linear equations *X = B with complex Hermitian matrix using factorization = U*D*U**H/= L*D*L**H computed by ZHETRF

zhfrk(l)

3 BLAS like routine for C in RFP Format

zhgeqz(l)

computes eigenvalues of complex matrix pair

zhpcon(l)

estimates reciprocal of condition number of complex Hermitian packed matrix using factorization = U*D*U**H/= L*D*L**H computed by ZHPTRF

zhpev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

zhpevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

zhpevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

zhpgst(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form, using packed storage

zhpgv(l)

computes all eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhpgvd(l)

computes all eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhpgvx(l)

computes selected eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhpmv(l)

performs matrix-vector operation y := alpha**x + beta*y

zhpr(l)

performs hermitian rank 1 operation := alpha*x*conjg +

zhpr2(l)

performs hermitian rank 2 operation := alpha*x*conjg + conjg*y*conjg +

zhprfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward ...

zhpsv(l)

computes solution to complex system of linear equations * X = B

zhpsvx(l)

uses diagonal pivoting factorization = U*D*U**H or = L*D*L**H to compute solution to complex system of linear equations * X = B, where is N-by-N Hermitian ...

zhptrd(l)

reduces complex Hermitian matrix stored in packed form to real symmetric tridiagonal form T by unitary similarity transformation

zhptrf(l)

computes factorization of complex Hermitian packed matrix using Bunch-Kaufman diagonal pivoting method

zhptri(l)

computes inverse of complex Hermitian indefinite matrix in packed storage using factorization = U*D*U**H/= L*D*L**H computed by ZHPTRF

zhptrs(l)

solves system of linear equations *X = B with complex Hermitian matrix stored in packed format using factorization = U*D*U**H/= L*D*L**H computed by ZHPTRF

zhsein(l)

uses inverse iteration to find specified right/left eigenvectors of complex upper Hessenberg matrix H

zhseqr(l)

ZHSEQR compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

zic(8)

timezone compiler

zile(1)

Zile Is Lossy Emacs

zim(1)

Desktop Wiki Editor

zip(1)

package/compress files

zip(3)

Utility for reading/creating 'zip' archives

zip_add(3)

.Nm zip_replace add file to zip archive/replace file in zip archive

zip_add_dir(3)

add directory to zip archive

zip_close(3)

close zip archive

zip_delete(3)

delete file from zip archive

zip_error_clear(3)

.Nm zip_file_error_clear clear error state for archive/file

zip_error_get(3)

.Nm zip_file_error_get get error codes for archive/file

zip_error_get_sys_type(3)

system error code

zip_error_to_str(3)

string representation of zip error

zip_errors(3)

all libzip error codes

zip_fclose(3)

close file in zip archive

zip_file_error_clear(3)

.Nm zip_file_error_clear clear error state for archive/file

zip_file_error_get(3)

.Nm zip_file_error_get get error codes for archive/file

zip_file_strerror(3)

.Nm zip_strerror get string representation for zip error

zip_fopen(3)

.Nm zip_fopen_index open file in zip archive for reading

zip_fopen_index(3)

.Nm zip_fopen_index open file in zip archive for reading

zip_fread(3)

read from file

zip_get_archive_comment(3)

zip archive comment

zip_get_archive_flag(3)

status flags for zip

zip_get_file_comment(3)

comment for file in zip

zip_get_name(3)

name of file by index

zip_get_num_files(3)

number of files in archive

zip_name_locate(3)

index of file by name

zip_open(3)

open zip archive

zip_rename(3)

rename file in zip archive

zip_replace(3)

.Nm zip_replace add file to zip archive/replace file in zip archive

zip_set_archive_comment(3)

set zip archive comment

zip_set_archive_flag(3)

set zip archive flag

zip_set_file_comment(3)

set comment for file in zip

zip_source_buffer(3)

create zip data source from buffer

zip_source_file(3)

create data source from file

zip_source_filep(3)

create data source from FILE *

zip_source_free(3)

free zip data source

zip_source_function(3)

create data source from function

zip_source_zip(3)

create data source from zip file

zip_stat(3)

.Nm zip_stat_index get info about file

zip_stat_index(3)

.Nm zip_stat_index get info about file

zip_stat_init(3)

initialize zip_stat structure

zip_strerror(3)

.Nm zip_strerror get string representation for zip error

zip_unchange(3)

undo changes to file in zip archive

zip_unchange_all(3)

undo all changes in zip archive

zip_unchange_archive(3)

undo global changes to zip archive

zipcloak(1)

encrypt entries in zipfile

zipcmp(1)

compare contents of zip archives

zipgrep(1)

search files in ZIP archive for lines matching pattern

zipinfo(1)

ZIP archive

zipmerge(1)

merge zip archives

zipnote(1)

comments in zipfile to stdout, edit comments and rename files in zipfile

zipsplit(1)

split zipfile into smaller zipfiles

ziptorrent(1)

torrentzip zip archives

zla_gbamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

zla_gbrcond_c(l)

ZLA_GBRCOND_C Compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector

zla_gbrcond_x(l)

ZLA_GBRCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_gbrfsx_extended(l)

computes

zla_gbrpvgrw(l)

computes

zla_geamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

zla_gercond_c(l)

ZLA_GERCOND_C compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector

zla_gercond_x(l)

ZLA_GERCOND_X compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_gerfsx_extended(l)

computes

zla_heamv(l)

performs matrix-vector operation y := alpha*abs*abs + beta*abs

zla_hercond_c(l)

ZLA_HERCOND_C compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector

zla_hercond_x(l)

ZLA_HERCOND_X compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_herfsx_extended(l)

computes

zla_herpvgrw(l)

computes

zla_lin_berr(l)

ZLA_LIN_BERR compute componentwise relative backward error from formula max ( abs(R)/( abs(op)*abs + abs ) ) where abs is componentwise absolute value of ...

zla_porcond_c(l)

DLA_PORCOND_C Compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector Arguments ========= C DOUBLE PRECISION vector

zla_porcond_x(l)

ZLA_PORCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_porfsx_extended(l)

computes

zla_porpvgrw(l)

computes

zla_rpvgrw(l)

computes

zla_syamv(l)

performs matrix-vector operation y := alpha*abs*abs + beta*abs

zla_syrcond_c(l)

ZLA_SYRCOND_C Compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector

zla_syrcond_x(l)

ZLA_SYRCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_syrfsx_extended(l)

computes

zla_syrpvgrw(l)

computes

zla_wwaddw(l)

ZLA_WWADDW add vector W into doubled-single vector

zlabrd(l)

reduces first NB rows and columns of complex general m by n matrix to upper or lower real bidiagonal form by unitary transformation Q' * * P, and returns ...

zlacgv(l)

conjugates complex vector of length N

zlacn2(l)

estimates 1-norm of square, complex matrix

zlacon(l)

estimates 1-norm of square, complex matrix

zlacp2(l)

copies all/part of real two-dimensional matrix to complex matrix B

zlacpy(l)

copies all/part of two-dimensional matrix to another matrix B

zlacrm(l)

performs very simple matrix-matrix multiplication

zlacrt(l)

performs operation ==> where c/s are complex/vectors x/y are complex

zladiv(l)

:= X/Y, where X and Y are complex

zlaed0(l)

divide and conquer method, ZLAED0 computes all eigenvalues of symmetric tridiagonal matrix which is one diagonal block of those from reducing dense or band ...

zlaed7(l)

computes updated eigensystem of diagonal matrix after modification by rank-one symmetric matrix

zlaed8(l)

merges two sets of eigenvalues together into single sorted set

zlaein(l)

uses inverse iteration to find right/left eigenvector corresponding to eigenvalue W of complex upper Hessenberg matrix H

zlaesy(l)

computes eigendecomposition of 2-by-2 symmetric matrix ( ; ) provided norm of matrix of eigenvectors is larger than some threshold value

zlaev2(l)

computes eigendecomposition of 2-by-2 Hermitian matrix [ B ] [ CONJG C ]

zlag2c(l)

converts COMPLEX*16 matrix, SA, to COMPLEX matrix

zlags2(l)

computes 2-by-2 unitary matrices U, V and Q, such that if then U'**Q = U'**Q = and V'*B*Q = V'**Q = or if then U'**Q = U'**Q = and V'*B*Q = V'**Q = where U = ...

zlagtm(l)

performs matrix-vector product of form B := alpha * * X + beta * B where is tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta ...

zlahef(l)

computes partial factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

zlahqr(l)

ZLAHQR i auxiliary routine called by CHSEQR to update eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with Hessenberg submatrix in ...

zlahr2(l)

reduces first NB columns of complex general n-BY- matrix so that elements below k-th subdiagonal are zero

zlahrd(l)

reduces first NB columns of complex general n-by- matrix so that elements below k-th subdiagonal are zero

zlaic1(l)

applies one step of incremental condition estimation in its simplest version

zlals0(l)

applies back multiplying factors of either left/right singular vector matrix of diagonal matrix appended by row to right hand side matrix B in solving least ...

zlalsa(l)

is itermediate step in solving least squares problem by computing SVD of coefficient matrix in compact form

zlalsd(l)

uses singular value decomposition of to solve least squares problem of finding X to minimize Euclidean norm of each column of *X-B, where is N-by-N upper ...

zlangb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n band matrix , with kl sub-diagonals and ku ...

zlange(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex matrix

zlangt(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex tridiagonal matrix

zlanhb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n hermitian band matrix , with k super-diagonals

zlanhe(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex hermitian matrix

zlanhf(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex Hermitian matrix in RFP format

zlanhp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex hermitian matrix , supplied in packed form

zlanhs(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of Hessenberg matrix

zlanht(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex Hermitian tridiagonal matrix

zlansb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n symmetric band matrix , with k super-diagonals

zlansp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex symmetric matrix , supplied in packed form

zlansy(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex symmetric matrix

zlantb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n triangular band matrix , with diagonals

zlantp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of triangular matrix , supplied in packed form

zlantr(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of trapezoidal or triangular matrix

zlapll(l)

two column vectors X and Y, let =

zlapmt(l)

rearranges columns of M by N matrix X as specified by permutation K,K,...,K of integers 1,...,N

zlaqgb(l)

equilibrates general M by N band matrix with KL subdiagonals/KU superdiagonals using row/scaling factors in vectors R/C

zlaqge(l)

equilibrates general M by N matrix using row/column scaling factors in vectors R/C

zlaqhb(l)

equilibrates symmetric band matrix using scaling factors in vector S

zlaqhe(l)

equilibrates Hermitian matrix using scaling factors in vector S

zlaqhp(l)

equilibrates Hermitian matrix using scaling factors in vector S

zlaqp2(l)

computes QR factorization with column pivoting of block

zlaqps(l)

computes step of QR factorization with column pivoting of complex M-by-N matrix by using Blas-3

zlaqr0(l)

ZLAQR0 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

zlaqr1(l)

zlaqr2(l)

zlaqr3(l)

zlaqr4(l)

ZLAQR4 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

zlaqr5(l)

zlaqsb(l)

equilibrates symmetric band matrix using scaling factors in vector S

zlaqsp(l)

equilibrates symmetric matrix using scaling factors in vector S

zlaqsy(l)

equilibrates symmetric matrix using scaling factors in vector S

zlar1v(l)

computes r-th column of inverse of sumbmatrix in rows B1 through BN of tridiagonal matrix L D L^T - sigma I

zlar2v(l)

applies vector of complex plane rotations with real cosines from both sides to sequence of 2-by-2 complex Hermitian matrices

zlarcm(l)

performs very simple matrix-matrix multiplication

zlarf(l)

applies complex elementary reflector H to complex M-by-N matrix C, from either left or right

zlarfb(l)

applies complex block reflector H or its transpose H' to complex M-by-N matrix C, from either left or right

zlarfg(l)

generates complex elementary reflector H of order n, such that H' * = , H' * H = I

zlarfp(l)

generates complex elementary reflector H of order n, such that H' * = , H' * H = I

zlarft(l)

forms triangular factor T of complex block reflector H of order n, which is defined as product of k elementary reflectors

zlarfx(l)

applies complex elementary reflector H to complex m by n matrix C, from either left or right

zlargv(l)

generates vector of complex plane rotations with real cosines, determined by elements of complex vectors x and y

zlarnv(l)

returns vector of n random complex numbers from uniform/normal distribution

zlarrv(l)

computes eigenvectors of tridiagonal matrix T = L D L^T given L, D and APPROXIMATIONS to eigenvalues of L D L^T

zlarscl2(l)

performs reciprocal diagonal scaling on vector

zlartg(l)

generates plane rotation so that [ CS SN ] [ F ] [ R ] [ __ ]

zlartv(l)

applies vector of complex plane rotations with real cosines to elements of complex vectors x/y

zlarz(l)

applies complex elementary reflector H to complex M-by-N matrix C, from either left or right

zlarzb(l)

applies complex block reflector H/its transpose H**H to complex distributed M-by-N C from left/right

zlarzt(l)

forms triangular factor T of complex block reflector H of order > n, which is defined as product of k elementary reflectors

zlascl(l)

multiplies M by N complex matrix by real scalar CTO/CFROM

zlascl2(l)

performs diagonal scaling on vector

zlaset(l)

initializes 2-D array to BETA on diagonal/ALPHA on offdiagonals

zlasr(l)

applies sequence of real plane rotations to complex matrix , from either left or right

zlassq(l)

returns values scl and ssq such that *ssq = x**2 +...+ x**2 + *sumsq

zlaswp(l)

performs series of row interchanges on matrix

zlasyf(l)

computes partial factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

zlat2c(l)

converts COMPLEX*16 triangular matrix, SA, to COMPLEX triangular matrix

zlatbs(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

zlatdf(l)

computes contribution to reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that norm of x is as large as possible

zlatps(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

zlatrd(l)

reduces NB rows and columns of complex Hermitian matrix to Hermitian tridiagonal form by unitary similarity transformation Q' * * Q, and returns matrices V and ...

zlatrs(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

zlatrz(l)

factors M-by- complex upper trapezoidal matrix [ A1 A2 ] = [ ] as * Z by means of unitary transformations, where Z is -by- unitary matrix and, R and A1 are ...

zlatzm(l)

routine i deprecated/has been replaced by routine ZUNMRZ

zlauu2(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

zlauum(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

zless(1)

file perusal filter for crt viewing of compressed text

zlib(3)

compression/decompression library

zlib_stub(3)

Zlib Compression interface

zlist(7)

generic type-free list container

zloop(7)

event-driven reactor

zmergelog(1)

merge gzipped http log files by date

zmore(1)

file perusal filter for crt viewing of compressed text

zmq(7)

0MQ lightweight messaging kernel

zmq_bind(3)

accept incoming connections on socket

zmq_close(3)

close 0MQ socket

zmq_connect(3)

create outgoing connection from socket

zmq_cpp(7)

interface between 0MQ/C++ applications

zmq_ctx_destroy(3)

destroy 0MQ context

zmq_ctx_get(3)

context options

zmq_ctx_new(3)

create new 0MQ context

zmq_ctx_set(3)

set context options

zmq_device(3)

start built-in 0MQ device

zmq_disconnect(3)

Disconnect socket

zmq_epgm(7)

0MQ reliable multicast transport using PGM

zmq_errno(3)

value of errno for calling thread

zmq_getsockopt(3)

0MQ socket options

zmq_init(3)

initialise 0MQ context

zmq_inproc(7)

0MQ local in-process communication transport

zmq_ipc(7)

0MQ local inter-process communication transport

zmq_msg_close(3)

release 0MQ message

zmq_msg_copy(3)

copy content of message to another message

zmq_msg_data(3)

pointer to message content

zmq_msg_get(3)

message property

zmq_msg_init(3)

initialise empty 0MQ message

zmq_msg_init_data(3)

initialise 0MQ message from supplied buffer

zmq_msg_init_size(3)

initialise 0MQ message of specified size

zmq_msg_more(3)

indicate if there are more message parts to receive

zmq_msg_move(3)

move content of message to another message

zmq_msg_recv(3)

receive message part from socket

zmq_msg_send(3)

send message part on socket

zmq_msg_set(3)

set message property

zmq_msg_size(3)

message content size in bytes

zmq_pgm(7)

0MQ reliable multicast transport using PGM

zmq_poll(3)

input/output multiplexing

zmq_proxy(3)

start built-in 0MQ proxy

zmq_recv(3)

receive message part from socket

zmq_recvmsg(3)

receive message part from socket

zmq_send(3)

send message part on socket

zmq_sendmsg(3)

send message part on socket

zmq_setsockopt(3)

set 0MQ socket options

zmq_socket(3)

create 0MQ socket

zmq_socket_monitor(3)

register monitoring callback

zmq_strerror(3)

0MQ error message string

zmq_tcp(7)

0MQ unicast transport using TCP

zmq_term(3)

terminate 0MQ context

zmq_unbind(3)

Stop accepting connections on socket

zmq_version(3)

report 0MQ library version

zmsg(7)

working with multipart messages

zmutex(7)

working with mutexes

znc(1)

advanced IRC bouncer

znc-buildmod(1)

compile ZNC modules

znc-config(1)

get info about installed version of ZNC

znew(1)

recompress .Z files to .gz files

zoid(1)

modular perl shell

zoidberg(3)

modular perl shell

zoidbuiltins(1)

Zoidberg's builtins

zoiddevel(1)

Development documentation for zoid

zoidfaq(1)

Frequently Asked Questions about Zoidberg

zoiduser(1)

Extended user documentation for zoid

zone2ldap(1)

zone2sql(8)

Convert ISC Bind zones to SQL

zonec(8)

NSD zone compiler

zonecheck(1)

DNS zone checking tool

zonesigner(1)

Generates encryption keys/signs DNS zone

zonetab2pot.py(1)

Converts timezone list to PO file template

zonetodb(1)

make PostgreSQL table from zone

zoo(1)

change archives of files in compressed form

zoom(1)

wander around magified desktop

zoom(6)

wander around magnified desktop

zoomsh(1)

ZOOM shell

zopeedit(1)

helper application that handles interaction between

zos-remote.conf(5)

audisp-racf plugin config file

zos_remote_selinux(8)

Security Enhanced Policy for zos_remote processes

zos_selinux(8)

Security Enhanced Policy for zos processes

zpbcon(l)

estimates reciprocal of condition number of complex Hermitian positive definite band matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPBTRF

zpbequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite band matrix/reduce its condition number

zpbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and banded, and provides error bounds and ...

zpbstf(l)

computes split Cholesky factorization of complex Hermitian positive definite band matrix

zpbsv(l)

computes solution to complex system of linear equations * X = B

zpbsvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

zpbtf2(l)

computes Cholesky factorization of complex Hermitian positive definite band matrix

zpbtrf(l)

computes Cholesky factorization of complex Hermitian positive definite band matrix

zpbtrs(l)

solves system of linear equations *X = B with Hermitian positive definite band matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPBTRF

zpftrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

zpftri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPFTRF

zpftrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPFTRF

zplay(1)

modem utility to record/play voice files

zpocon(l)

estimates reciprocal of condition number of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPOTRF

zpoequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite matrix/reduce its condition number

zpoequb(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix/reduce its condition number

zpool(8)

configures ZFS storage pools

zporfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite

zporfsx(l)

ZPORFSX improve computed solution to system of linear equations when coefficient matrix is symmetric positive definite, and provides error bounds and backward ...

zposv(l)

computes solution to complex system of linear equations * X = B

zposvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

zposvxx(l)

ZPOSVXX use Cholesky factorization = U**T*U or = L*L**T to compute solution to complex*16 system of linear equations * X = B, where is N-by-N symmetric ...

zpotf2(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

zpotrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

zpotri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPOTRF

zpotrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPOTRF

zppcon(l)

estimates reciprocal of condition number of complex Hermitian positive definite packed matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPPTRF

zppequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite matrix in packed storage/reduce its condition number

zpprfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and packed, and provides error bounds and ...

zppsv(l)

computes solution to complex system of linear equations * X = B

zppsvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

zpptrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix stored in packed format

zpptri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPPTRF

zpptrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix in packed storage using Cholesky factorization = U**H*U/= L*L**H computed by ...

zpstf2(l)

computes Cholesky factorization with complete pivoting of complex Hermitian positive semidefinite matrix

zpstrf(l)

computes Cholesky factorization with complete pivoting of complex Hermitian positive semidefinite matrix

zptcon(l)

computes reciprocal of condition number of complex Hermitian positive definite tridiagonal matrix using factorization = L*D*L**H/= U**H*D*U computed by ZPTTRF

zpteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric positive definite tridiagonal matrix by first factoring matrix using DPTTRF and then calling ZBDSQR ...

zptrfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and ...

zptsv(l)

computes solution to complex system of linear equations *X = B, where is N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS ...

zptsvx(l)

uses factorization = L*D*L**H to compute solution to complex system of linear equations *X = B, where is N-by-N Hermitian positive definite tridiagonal matrix ...

zpttrf(l)

computes L*D*L' factorization of complex Hermitian positive definite tridiagonal matrix

zpttrs(l)

solves tridiagonal system of form * X = B using factorization = U'*D*U/= L*D*L' computed by ZPTTRF

zptts2(l)

solves tridiagonal system of form * X = B using factorization = U'*D*U/= L*D*L' computed by ZPTTRF

zrancid(1)

Cisco config filter

zrot(l)

applies plane rotation, where cos is real and sin is complex, and vectors CX and CY are complex

zrotg(l)

ZROTG determine double complex Givens rotation

zrun(1)

automatically uncompress arguments to command

zscal(l)

ZSCAL scale vector by constant

zserv(8)

CERNLIB server program for transferring ZEBRA formatted files

zsh(1)

Z shell

zshall(1)

Z shell meta-man page

zshbuiltins(1)

zsh built-in commands

zshcalsys(1)

zsh calendar system

zshcompctl(1)

zsh programmable completion

zshcompsys(1)

zsh completion system

zshcompwid(1)

zsh completion widgets

zshcontrib(1)

user contributions to zsh

zshexpn(1)

zsh expansion/substitution

zshmisc(1)

everything/then some

zshmodules(1)

zsh loadable modules

zshoptions(1)

zsh options

zshparam(1)

zsh parameters

zshroadmap(1)

informal introduction to zsh manual

zshtcpsys(1)

zsh tcp system

zshzftpsys(1)

zftp function front-end

zshzle(1)

zsh editor

zsocket(7)

working with 0MQ sockets

zsockopt(7)

get/set 0MQ socket options

zsoelim(1)

interpret .so requests in groff input

zspcon(l)

estimates reciprocal of condition number of complex symmetric packed matrix using factorization = U*D*U**T/= L*D*L**T computed by ZSPTRF

zsplit(8)

reads big devices/files/makes compressed splitted image chunks of it

zspmv(l)

performs matrix-vector operation y := alpha**x + beta*y

zspr(l)

performs symmetric rank 1 operation := alpha*x*conjg +

zsprfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward ...

zspsv(l)

computes solution to complex system of linear equations * X = B

zspsvx(l)

uses diagonal pivoting factorization = U*D*U**T or = L*D*L**T to compute solution to complex system of linear equations * X = B, where is N-by-N symmetric ...

zsptrf(l)

computes factorization of complex symmetric matrix stored in packed format using Bunch-Kaufman diagonal pivoting method

zsptri(l)

computes inverse of complex symmetric indefinite matrix in packed storage using factorization = U*D*U**T/= L*D*L**T computed by ZSPTRF

zsptrs(l)

solves system of linear equations *X = B with complex symmetric matrix stored in packed format using factorization = U*D*U**T/= L*D*L**T computed by ZSPTRF

zssh(1)

interactive file transfer wrapper for ssh

zstedc(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using divide and conquer method

zstegr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

zstein(l)

computes eigenvectors of real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration

zstemr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

zsteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using implicit QL or QR method

zstr(7)

sending/receiving strings

zstreamdump(8)

filter data in zfs send stream

zswap(l)

ZSWAP interchange two vectors

zsycon(l)

estimates reciprocal of condition number of complex symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by ZSYTRF

zsyequb(l)

computes row/column scalings intended to equilibrate symmetric matrix/reduce its condition number

zsymm(l)

performs one of matrix-matrix operations C := alpha**B + beta*C

zsymv(l)

performs matrix-vector operation y := alpha**x + beta*y

zsync(1)

Partial/differential file download client over HTTP

zsyncmake(1)

Build control file for zsync

zsyr(l)

performs symmetric rank 1 operation := alpha*x* +

zsyr2k(l)

performs one of symmetric rank 2k operations C := alpha**B' + alpha*B*' + beta*C

zsyrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

zsyrfsx(l)

ZSYRFSX improve computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

zsyrk(l)

performs one of symmetric rank k operations C := alpha**' + beta*C

zsysv(l)

computes solution to complex system of linear equations * X = B

zsysvx(l)

uses diagonal pivoting factorization to compute solution to complex system of linear equations * X = B

zsysvxx(l)

ZSYSVXX use diagonal pivoting factorization to compute solution to complex*16 system of linear equations * X = B, where is N-by-N symmetric matrix and X and B ...

zsytf2(l)

computes factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

zsytrf(l)

computes factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

zsytri(l)

computes inverse of complex symmetric indefinite matrix using factorization = U*D*U**T/= L*D*L**T computed by ZSYTRF

zsytrs(l)

solves system of linear equations *X = B with complex symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by ZSYTRF

ztbcon(l)

estimates reciprocal of condition number of triangular band matrix , in either 1-norm or infinity-norm

ztbmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ztbrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular band coefficient matrix

ztbsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ztbtrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ztelnet(1)

interactive file transfer wrapper for ssh

ztfsm(l)

3 BLAS like routine for in RFP Format

ztftri(l)

computes inverse of triangular matrix stored in RFP format

ztfttp(l)

copies triangular matrix from rectangular full packed format to standard packed format

ztfttr(l)

copies triangular matrix from rectangular full packed format to standard full format

ztgevc(l)

computes some or all of right/left eigenvectors of pair of complex matrices , where S and P are upper triangular

ztgex2(l)

swaps adjacent diagonal 1 by 1 blocks/

ztgexc(l)

reorders generalized Schur decomposition of complex matrix pair , using unitary equivalence transformation := Q * * Z', so that diagonal block of with row ...

ztgsen(l)

reorders generalized Schur decomposition of complex matrix pair (in terms of unitary equivalence trans- formation Q' * * Z), so that selected cluster of ...

ztgsja(l)

computes generalized singular value decomposition of two complex upper triangular matrices/B

ztgsna(l)

estimates reciprocal condition numbers for specified eigenvalues/eigenvectors of matrix pair

ztgsy2(l)

solves generalized Sylvester equation * R - L * B = scale D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices

ztgsyl(l)

solves generalized Sylvester equation

zthread(7)

working with system threads

ztpcon(l)

estimates reciprocal of condition number of packed triangular matrix , in either 1-norm or infinity-norm

ztpmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ztprfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular packed coefficient matrix

ztpsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ztptri(l)

computes inverse of complex upper/lower triangular matrix stored in packed format

ztptrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ztpttf(l)

copies triangular matrix from standard packed format to rectangular full packed format

ztpttr(l)

copies triangular matrix from standard packed format to standard full format

ztrcon(l)

estimates reciprocal of condition number of triangular matrix , in either 1-norm or infinity-norm

ztrevc(l)

computes some/all of right/left eigenvectors of complex upper triangular matrix T

ztrexc(l)

reorders Schur factorization of complex matrix = Q*T*Q**H, so that diagonal element of T with row index IFST is moved to row ILST

ztrmm(l)

performs one of matrix-matrix operations B := alpha*op*B, or B := alpha*B*op where alpha is scalar, B is m by n matrix, is unit, or non-unit, upper or lower ...

ztrmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ztrrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular coefficient matrix

ztrsen(l)

reorders Schur factorization of complex matrix = Q*T*Q**H, so that selected cluster of eigenvalues appears in leading positions on diagonal of upper triangular ...

ztrsm(l)

solves one of matrix equations op*X = alpha*B, or X*op = alpha*B

ztrsna(l)

estimates reciprocal condition numbers for specified eigenvalues/right eigenvectors of complex upper triangular matrix T

ztrsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ztrsyl(l)

solves complex Sylvester matrix equation

ztrti2(l)

computes inverse of complex upper/lower triangular matrix

ztrtri(l)

computes inverse of complex upper/lower triangular matrix

ztrtrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ztrttf(l)

copies triangular matrix from standard full format to rectangular full packed format

ztrttp(l)

copies triangular matrix from full format to standard packed format

ztzrqf(l)

routine i deprecated/has been replaced by routine ZTZRZF

ztzrzf(l)

reduces M-by-N complex upper trapezoidal matrix to upper triangular form by means of unitary transformations

zung2l(l)

generates m by n complex matrix Q with orthonormal columns

zung2r(l)

generates m by n complex matrix Q with orthonormal columns

zungbr(l)

generates one of complex unitary matrices Q/P**H determined by ZGEBRD when reducing complex matrix to bidiagonal form

zunghr(l)

generates complex unitary matrix Q which is defined as product of IHI-ILO elementary reflectors of order N, as returned by ZGEHRD

zungl2(l)

generates m-by-n complex matrix Q with orthonormal rows

zunglq(l)

generates M-by-N complex matrix Q with orthonormal rows

zungql(l)

generates M-by-N complex matrix Q with orthonormal columns

zungqr(l)

generates M-by-N complex matrix Q with orthonormal columns

zungr2(l)

generates m by n complex matrix Q with orthonormal rows

zungrq(l)

generates M-by-N complex matrix Q with orthonormal rows

zungtr(l)

generates complex unitary matrix Q which is defined as product of n-1 elementary reflectors of order N, as returned by ZHETRD

zunm2l(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunm2r(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunmbr(l)

VECT = 'Q', ZUNMBR overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmhr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunml2(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunmlq(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmql(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmqr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmr2(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunmr3(l)

overwrites general complex m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunmrq(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmrz(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmtr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zupgtr(l)

generates complex unitary matrix Q which is defined as product of n-1 elementary reflectors H of order n, as returned by ZHPTRD using packed storage

zupmtr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zvbi-atsc-cc(1)

ATSC Closed Caption decoder

zvbi-chains(1)

VBI proxy wrapper

zvbi-ntsc-cc(1)

closed caption decoder

zvbid(1)

VBI proxy daemon

zzip_close(3)

zzip_closedir(3)

zzip_compr_str(3)

zzip_dir_alloc(3)

zzip_dir_alloc_ext_io(3)

zzip_dir_close(3)

zzip_dir_fdopen(3)

zzip_dir_fdopen_ext_io(3)

zzip_dir_free(3)

zzip_dir_open(3)

zzip_dir_open_ext_io(3)

zzip_dir_read(3)

zzip_dir_real(3)

zzip_dir_stat(3)

zzip_dirfd(3)

zzip_dirhandle(3)

zzip_disk_buffer(3)

turn filehandle into mmapped zip disk archive handle

zzip_disk_close(3)

turn filehandle into mmapped zip disk archive handle

zzip_disk_entry_fopen(3)

openening file part wrapped within zip archive

zzip_disk_entry_strdup_comment(3)

helper functions for zip access api

zzip_disk_entry_strdup_name(3)

helper functions for zip access api

zzip_disk_entry_to_data(3)

helper functions for zip access api

zzip_disk_entry_to_file_header(3)

helper functions for zip access api

zzip_disk_fclose(3)

openening file part wrapped within zip archive

zzip_disk_feof(3)

openening file part wrapped within zip archive

zzip_disk_findfile(3)

search for files in zip central directory

zzip_disk_findfirst(3)

search for files in zip central directory

zzip_disk_findmatch(3)

search for files in zip central directory

zzip_disk_findnext(3)

search for files in zip central directory

zzip_disk_fopen(3)

openening file part wrapped within zip archive

zzip_disk_fread(3)

openening file part wrapped within zip archive

zzip_disk_init(3)

turn filehandle into mmapped zip disk archive handle

zzip_disk_mmap(3)

turn filehandle into mmapped zip disk archive handle

zzip_disk_munmap(3)

turn filehandle into mmapped zip disk archive handle

zzip_disk_new(3)

turn filehandle into mmapped zip disk archive handle

zzip_disk_open(3)

turn filehandle into mmapped zip disk archive handle

zzip_entry_data_offset(3)

helper functions for zip access api

zzip_entry_fclose(3)

open file within zip disk for reading

zzip_entry_feof(3)

open file within zip disk for reading

zzip_entry_ffile(3)

open file within zip disk for reading

zzip_entry_findfile(3)

search for files in zip central directory

zzip_entry_findfirst(3)

search for files in zip central directory

zzip_entry_findmatch(3)

search for files in zip central directory

zzip_entry_findnext(3)

search for files in zip central directory

zzip_entry_fopen(3)

open file within zip disk for reading

zzip_entry_fread(3)

open file within zip disk for reading

zzip_entry_fread_file_header(3)

helper functions for zip access api

zzip_entry_free(3)

search for files in zip central directory

zzip_entry_strdup_name(3)

helper functions for zip access api

zzip_errno(3)

zzip_error(3)

zzip_fclose(3)

zzip_file_close(3)

zzip_file_open(3)

zzip_file_read(3)

zzip_file_real(3)

zzip_file_stat(3)

zzip_fopen(3)

zzip_fread(3)

zzip_freopen(3)

zzip_fstat(3)

zzip_get_default_io(3)

zzip_inflate_init(3)

zzip_init_io(3)

zzip_open(3)

zzip_open_ext_io(3)

zzip_open_shared_io(3)

zzip_opendir(3)

zzip_opendir_ext_io(3)

zzip_read(3)

zzip_readdir(3)

zzip_realdir(3)

zzip_realfd(3)

zzip_rewind(3)

zzip_rewinddir(3)

zzip_seek(3)

zzip_seek32(3)

zzip_seekdir(3)

zzip_seekdir32(3)

zzip_seterror(3)

zzip_strerror(3)

zzip_strerror_of(3)

zzip_tell(3)

zzip_tell32(3)

zzip_telldir(3)

zzip_telldir32(3)