Skip to content


Folders and files

Last commit message
Last commit date

Latest commit


Repository files navigation


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.


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
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.


To compile and install from source code, run

    make test
    make install

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


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
    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
  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)