Introduction

qml is a library for statistics, linear algebra, and optimization in kdb+. It provides an interface between the q programming language and numerical libraries such as LAPACK.

License

qml is free software, distributed under a BSD-style license. It is provided in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranties of MERCHANTABILITY and FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt for more details.

qml is linked against several other libraries. The copyrights and licenses for these libraries are also listed in LICENSE.txt.

Installation

To compile and install from source code, run

./configure
make
make test
make install

To install a precompiled binary, copy qml.q into the same directory as q.k, and copy qml.dll or qml.so into the same directory as q.exe or q. Then run test.q.

Usage

Load with

q)\l qml.q

All functions are in the .qml namespace. Numerical arguments are automatically converted into floating-point. Matrixes are in the usual row-major layout (lists of row vectors). Complex numbers are represented as pairs of their real and imaginary parts.

q).qml.nicdf .25 .5 .975                  / normal distribution quantiles
-0.6744898 0 1.959964

q).qml.mchol (1 2 1;2 5 4;1 4 6)          / Cholesky factorization
1 2 1
0 1 2
0 0 1

q).qml.poly 2 -9 16 -15                   / solve 2x^3-9x^2+16x-15=0
2.5
1 1.414214
1 -1.414214

q).qml.mlsq[(1 1;1 2;1 3;1 4);11 2 -3 -4] / fit line
14 -5f

q).qml.conmin[{x*y+1};{1-(x*x)+y*y};0 0]  / minimize x(y+1) s.t. x^2+y^2<=1
-0.8660254 0.5

Constants and functions

pi pi e e eps smallest representable step from 1.

sin[x] sine cos[x] cosine tan[x] tangent asin[x] arcsine acos[x] arccosine atan[x] arctangent atan2[x;y] atan[x%y] sinh[x] hyperbolic sine cosh[x] hyperbolic cosine tanh[x] hyperbolic tangent asinh[x] hyperbolic arcsine acosh[x] hyperbolic arccosine atanh[x] hyperbolic arctangent

exp[x] exponential expm1[x] exp[x]-1 log[x] logarithm log10[x] base-10 logarithm logb[x] extract binary exponent log1p[x] log[1+x] pow[a;x] exponentiation sqrt[x] square root cbrt[x] cube root hypot[x;y] sqrt[pow[x;2]+pow[y;2]] floor[x] round downward ceil[x] round upward fabs[x] absolute value fmod[x;y] remainder of x%y

erf[x] error function erfc[x] complementary error function lgamma[x] log of absolute value of gamma function gamma[x] gamma function beta[x;y] beta function pgamma[a;x] lower incomplete gamma function (a>0) pgammac[a;x] upper incomplete gamma function (a>0) pgammar[a;x] regularized lower incomplete gamma function (a>0) pgammarc[a;x] regularized upper incomplete gamma function (a>0) ipgammarc[a;p] inverse complementary regularized incomplete gamma function (a>0,p>=.5) pbeta[a;b;x] incomplete beta function (a,b>0) pbetar[a;b;x] regularized incomplete beta function (a,b>0) ipbetar[a;b;p] inverse regularized incomplete beta function (a,b>0) j0[x] order 0 Bessel function j1[x] order 1 Bessel function y0[x] order 0 Bessel function of the second kind y1[x] order 1 Bessel function of the second kind

ncdf[x] CDF of normal distribution nicdf[p] its inverse c2cdf[k;x] CDF of chi-squared distribution (k>=1) c2icdf[k;p] its inverse stcdf[k;x] CDF of Student's t-distribution (natural k) sticdf[k;p] its inverse fcdf[d1;d2;x] CDF of F-distribution (d1,d2>=1,x>=0) ficdf[d1;d2;p] its inverse gcdf[k;th;x] CDF of gamma distribution gicdf[k;th;p] its inverse bncdf[k;n;p] CDF of binomial distribution bnicdf[k;n;x] its inverse for p (k<n) pscdf[k;lambda] CDF of Poisson distribution psicdf[k;p] its inverse for lambda smcdf[n;e] CDF for one-sided Kolmogorov-Smirnov test smicdf[n;e] its inverse kcdf[x] CDF for Kolmogorov distribution kicdf[p] its inverse (p>=1e-8)

diag[diag] make diagonal matrix mdim[matrix] number of (rows; columns) mdiag[matrix] extract main diagonal mdet[matrix] determinant mrank[matrix] rank minv[matrix] inverse mpinv[matrix] pseudoinverse dot[a;b] dot product mm[A;B] multiply mmx[opt;A;B] mm[] with options lflip: flip A rflip: flip B ms[A;B] solve B=A mm X, A is triangular mev[matrix] (eigenvalues; eigenvectors) sorted by decreasing modulus mchol[matrix] Cholesky factorization upper matrix mqr[matrix] QR factorization: (Q; R) mqrp[matrix] QR factorization with column pivoting: (Q; R; P), matrix@\:P=Q mm R mlup[matrix] LUP factorization with row pivoting: (L; U; P), matrix[P]=L mm U msvd[matrix] singular value decomposition: (U; Sigma; V) mkron[A;B] Kronecker product

poly[coef] roots of a polynomial (highest-degree coefficient first)

mls[A;B] solve B=A mm X mlsx[opt;A;B] mls[] with options equi: equilibrate the system (default: don't) flip: flip A, and flip B and X unless B is a vector mlsq[A;B] solve min ||B-A mm X|| mlsqx[opt;A;B] mlsq[] with options svd: use SVD algorithm (default: QR or LQ) flip: flip A, and flip B and X unless B is a vector

root[f;(x0;x1)] find root on interval (f(x0)f(x1)<0) rootx[opt;f;(x0;x1)] root[] with options (as dictionary or mixed list) iter: max iterations (default: 100) tol: numerical tolerance (default: ~1e-8) full: full output (default: only x) quiet: return null on failure (default: signal) solve[eqs;x0] solve nonlinear equations (given as functions) solvex[opt;eqs;x0] solve[] with options iter: max iterations (default: 1000) tol: numerical tolerance (default: ~1e-8) full: full output (default: only x) quiet: return null on failure (default: signal) steps: RK steps per iteration (default: 1) rk: use RK steps only (default: RK, SLP) slp: use SLP steps only (default: RK, SLP) line[f;base;x0] line search for minimum from base linex[opt;f;base;x0] line[] with same options as rootx[] min[f;x0] find unconstrained minimum min[(f;df);x0] min[] with analytic gradient function minx[opt;f;x0] min[] with same options as solvex[], plus nm: use Nelder–Mead method (default: CONMAX) sbplx: use Subplex method (default: CONMAX) conmin[f;cons;x0] find constrained minimum (functions cons>=0) conmin[(f;df);flip(cons;dcons);x0] conmin[] with analytic gradient functions conminx[opt;f;cons;x0] conmin[] with same options as solvex[], plus lincon: assume linear cons (default: nonlinear) `cobyla: use COBYLA method (default: CONMAX)