-
Notifications
You must be signed in to change notification settings - Fork 34
/
Copy pathREADME.txt
202 lines (170 loc) · 7.79 KB
/
README.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
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)