@numero-uno-jpn/rstats 0.0.0-stage → 0.6.1

package/dist/numerics.js

@@ -0,0 +1,2 @@
+/*! rStats.js 0.6.1 | MIT License | includes code ported from SciPy, Boost.Math, statsmodels, LAPACK and others: see THIRD_PARTY_NOTICES.md at https://github.com/numero-uno-jpn/rStats.js */
+import{a as H,b as T,c as D}from"./chunks/chunk-TPC6MTYC.js";import"./chunks/chunk-DRNMIEYH.js";import{a as M,f as j}from"./chunks/chunk-NOCEAM44.js";import{b as S}from"./chunks/chunk-7NK4SA6B.js";import"./chunks/chunk-UGUQYWRQ.js";function x(o,l,t="mean"){if(o.length!==l.length)throw new RangeError("'x' and 'y' lengths differ");let n=[];for(let r=0;r<o.length;r++)!Number.isNaN(o[r])&&!Number.isNaN(l[r])&&n.push(r);n.sort((r,s)=>o[r]-o[s]);let e=typeof t=="function"?t:t==="min"?r=>Math.min(...r):t==="max"?r=>Math.max(...r):S,a=[],f=[];for(let r=0;r<n.length;){let s=o[n[r]],c=r+1;for(;c<n.length&&o[n[c]]===s;)c++;a.push(s),f.push(c-r===1?l[n[r]]:e(n.slice(r,c).map(i=>l[i]))),r=c}return{x:a,y:f}}function F(o,l,t,n){let e=(n-o[t])/(o[t+1]-o[t]);return l[t]+(l[t+1]-l[t])*e}function O(o,l,t){let n=(e,a)=>e===0?0:e*a;return n(1-t,o[l])+n(t,o[l+1])}function X(o,l,t={}){let{method:n="linear",n:e=50,f:a=0,rule:f=1,ties:r="mean"}=t,s=x(o,l,r),c=s.x.length;if(c<=1&&n==="linear")throw new RangeError("need at least two non-NA values to interpolate");if(c===0)throw new RangeError("zero non-NA points");let[i,p]=typeof f=="number"?[f,f]:f,d=t.yleft??(i===1?NaN:s.y[0]),h=t.yright??(p===1?NaN:s.y[c-1]),m;if(t.xout!==void 0)m=Array.from(t.xout);else{if(e<=0)throw new RangeError("'approx' requires n >= 1");m=M(s.x[0],s.x[c-1],e)}let g=s.x,u=s.y,w=j(m,g),y=m.map((b,A)=>{let R=w[A];if(Number.isNaN(R))return NaN;if(R===0)return d;let E=R-1;return b===g[E]?u[E]:R===c?h:n==="linear"?F(g,u,E,b):O(u,E,a)});return{x:m,y}}function v(o,l){let t=o.length,n=new Array(t).fill(0),e=new Array(t).fill(0),a=new Array(t).fill(0);if(t<2)return{b:n,c:e,d:a};if(t<3)return n[0]=(l[1]-l[0])/(o[1]-o[0]),n[1]=n[0],{b:n,c:e,d:a};let f=t-1;a[0]=o[1]-o[0],e[1]=(l[1]-l[0])/a[0];for(let r=1;r<f;r++)a[r]=o[r+1]-o[r],n[r]=2*(a[r-1]+a[r]),e[r+1]=(l[r+1]-l[r])/a[r],e[r]=e[r+1]-e[r];n[0]=-a[0],n[f]=-a[t-2],e[0]=0,e[f]=0,t>3&&(e[0]=e[2]/(o[3]-o[1])-e[1]/(o[2]-o[0]),e[f]=e[t-2]/(o[f]-o[t-3])-e[t-3]/(o[t-2]-o[t-4]),e[0]=e[0]*a[0]*a[0]/(o[3]-o[0]),e[f]=-e[f]*a[t-2]*a[t-2]/(o[f]-o[t-4]));for(let r=1;r<t;r++){let s=a[r-1]/n[r-1];n[r]=n[r]-s*a[r-1],e[r]=e[r]-s*e[r-1]}e[f]=e[f]/n[f];for(let r=t-2;r>=0;r--)e[r]=(e[r]-a[r]*e[r+1])/n[r];n[f]=(l[f]-l[t-2])/a[t-2]+a[t-2]*(e[t-2]+2*e[f]);for(let r=0;r<f;r++)n[r]=(l[r+1]-l[r])/a[r]-a[r]*(e[r+1]+2*e[r]),a[r]=(e[r+1]-e[r])/a[r],e[r]=3*e[r];return e[f]=3*e[f],a[f]=a[t-2],{b:n,c:e,d:a}}function z(o,l,t){let n=o.length,e=new Array(n).fill(0),a=new Array(n).fill(0),f=new Array(n).fill(0);for(let r=0;r<n-1;r++){let s=o[r+1]-o[r];e[r]=(l[r+1]-l[r])/s-s*(t[r+1]+2*t[r]),a[r]=3*t[r],f[r]=(t[r+1]-t[r])/s}return{b:e,c:a,d:f}}function J(o,l){let t=o.length;if(t<3)return v(o,l);let n=Array.from({length:t-1},(c,i)=>o[i+1]-o[i]),e=n.map((c,i)=>(l[i+1]-l[i])/c),a=new Array(t).fill(0),f=new Array(t).fill(0);for(let c=1;c<t-1;c++)a[c]=2*(n[c-1]+n[c]),f[c]=e[c]-e[c-1];for(let c=2;c<t-1;c++){let i=n[c-1]/a[c-1];a[c]=a[c]-i*n[c-1],f[c]=f[c]-i*f[c-1]}let r=new Array(t).fill(0);r[t-2]=f[t-2]/a[t-2];for(let c=t-3;c>=1;c--)r[c]=(f[c]-n[c]*r[c+1])/a[c];let s=z(o,l,r);return s.b[t-1]=e[t-2]+n[t-2]*r[t-2],s}function P(o,l){let t=o.length;if(l[0]!==l[t-1])throw new RangeError("periodic spline needs y[1] == y[n]");if(t<3)return{b:new Array(t).fill(0),c:new Array(t).fill(0),d:new Array(t).fill(0)};let n=t-1,e=Array.from({length:n},(u,w)=>o[w+1]-o[w]),a=e.map((u,w)=>(l[w+1]-l[w])/u),f=u=>u===0?n-1:u-1,r=Array.from({length:n},(u,w)=>2*(e[f(w)]+e[w])),s=Array.from({length:n},(u,w)=>a[w]-a[f(w)]),c=e.slice(),i=new Array(n).fill(0);i[0]=e[n-1],i[n-2]=i[n-2]+e[n-2];let p=i[0],d=r[n-1],h=s[n-1];for(let u=0;u<n-1;u++){if(u+1<n-1){let y=e[u]/r[u];r[u+1]=r[u+1]-y*c[u],i[u+1]=i[u+1]-y*i[u],s[u+1]=s[u+1]-y*s[u]}let w=p/r[u];d-=w*i[u],h-=w*s[u],u+1<n-1&&(p=(u+1===n-2?e[n-2]:0)-w*c[u])}let m=new Array(t).fill(0);m[n-1]=h/d;for(let u=n-2;u>=0;u--){let w=s[u]-i[u]*m[n-1]-(u<n-2?c[u]*m[u+1]:0);m[u]=w/r[u]}m[t-1]=m[0];let g=z(o,l,m);return g.b[t-1]=g.b[0],g.c[t-1]=g.c[0],g.d[t-1]=g.d[0],g}function Y(o,l){let t=o.length,{b:n,c:e,d:a}=v(o,l);if(t<2)return{b:n,c:e,d:a};let f=Array.from({length:t-1},(s,c)=>(l[c+1]-l[c])/(o[c+1]-o[c]));for(let s=0;s<t;s++){let c=f[s===0?0:s-1],i=f[s===t-1?t-2:s],p=Math.min(Math.abs(c),Math.abs(i)),d=c*i>0?i>0:n[s]>=0;n[s]=d?Math.min(Math.max(0,n[s]),3*p):Math.max(Math.min(0,n[s]),-3*p)}for(let s=0;s<t-1;s++){let c=o[s+1]-o[s],i=(l[s+1]-l[s])/c;e[s]=(3*i-2*n[s]-n[s+1])/c,a[s]=(n[s]+n[s+1]-2*i)/(c*c)}let r=o[t-1]-o[t-2];return e[t-1]=(n[t-2]+2*n[t-1]-3*(l[t-1]-l[t-2])/r)/r,a[t-1]=a[t-2],{b:n,c:e,d:a}}function q(o,l,t,n){let e=x(o,l,n),a=e.x.length;if(a===0)throw new RangeError("zero non-NA points");t==="periodic"&&e.y[a-1]!==e.y[0]&&(e.y[a-1]=e.y[0]),t==="hyman"&&B(e.y);let f=t==="fmm"?v(e.x,e.y):t==="natural"?J(e.x,e.y):t==="periodic"?P(e.x,e.y):t==="hyman"?Y(e.x,e.y):(()=>{throw new RangeError(`invalid spline method '${String(t)}'`)})();return{method:t,...e,...f}}function B(o){let l=!0,t=!0;for(let n=1;n<o.length;n++){let e=o[n]-o[n-1];e>=0||(l=!1),e<=0||(t=!1)}if(!l&&!t)throw new RangeError("'y' must be increasing or decreasing")}function C(o){let l=Math.trunc(o);if(!(l>=0&&l<=3))throw new RangeError("'deriv' must be between 0 and 3");return l}function I(o,l,t){let n=C(t),{x:e,y:a,b:f,c:r,d:s,method:c}=o,i=e.length,p=c==="natural",d=e[i-1]-e[0],h=0;return Array.from(l,m=>{let g=m;if(c==="periodic"&&i>1){let y=(g-e[0])%d;y<0&&(y+=d),g=e[0]+y}if(p&&n>0&&g<=e[0])return n===1?f[0]:0;if(!(e[h]<=g&&(h===i-1||g<=e[h+1]))){let y=0,b=i;for(;b-y>1;){let A=y+b>>1;e[A]<=g?y=A:b=A}h=y}let u=g-e[h],w=p&&g<e[0]?0:s[h];switch(n){case 0:return a[h]+u*(f[h]+u*(r[h]+u*w));case 1:return f[h]+u*(2*r[h]+u*(3*w));case 2:return 2*r[h]+u*(6*w);default:return 6*w}})}function G(o,l,t={}){let{method:n="fmm",ties:e="mean"}=t,a=q(o,l,n,e),f;if(t.xout!==void 0)f=Array.from(t.xout);else{let r=a.x.length,s=t.n??3*r;if(s<=0)throw new RangeError("'spline' requires n >= 1");f=M(t.xmin??a.x[0],t.xmax??a.x[r-1],s)}return{x:f,y:I(a,f,0)}}function K(o,l,t={}){let{method:n="fmm",ties:e="mean"}=t;if(n==="monoH.FC"){let f=x(o,l,e);if(f.x.length===0)throw new RangeError("zero non-NA points");let r=Q(f.x,f.y);return(s,c=0)=>L(f.x,f.y,r,s,c)}let a=q(o,l,n,e);return(f,r=0)=>I(a,f,r)}function Q(o,l){let t=o.length;if(t<2)throw new RangeError("length(m) must be at least two");let n=Array.from({length:t-1},(a,f)=>(l[f+1]-l[f])/(o[f+1]-o[f])),e=Array.from({length:t},(a,f)=>f===0?n[0]:f===t-1?n[t-2]:(n[f-1]+n[f])/2);for(let a=0;a<t-1;a++){let f=n[a];if(f===0){e[a]=0,e[a+1]=0;continue}let r=e[a]/f,s=e[a+1]/f,c=2*r+s-3,i=r+2*s-3;if(c>0&&i>0&&r*(c+i)<c*c){let p=3*f/Math.sqrt(r*r+s*s);e[a]=p*r,e[a+1]=p*s}}return e}function L(o,l,t,n,e){let a=C(e),f=o.length;return Array.from(n,r=>{if(Number.isNaN(r))return NaN;let s=0,c=f;for(;s<c;){let A=s+c>>1;o[A]<=r?s=A+1:c=A}let i=s;if(i===0||i===f){let A=i===0?0:f-1;return a===0?l[A]+t[A]*(r-o[A]):a===1?t[A]:0}let p=o[i-1],d=o[i]-p,h=(r-p)/d,m=h-1,g=l[i-1],u=l[i],w=t[i-1],y=t[i],b=(u-g)/d;switch(a){case 0:{let A=h*h*(3-2*h);return g*(1-A)+d*w*(h*m*m)+u*A+d*y*(h*h*m)}case 1:return b*(-6*h*m)+w*(m*(3*h-1))+y*(h*(3*h-2));case 2:return(b*(6-12*h)+w*(6*h-4)+y*(6*h-2))/d;default:return(-12*b+6*w+6*y)/(d*d)}})}function U(o,l,t){let n=o.length;if(l.length!==n||t.length!==n)throw new RangeError("'x', 'y' and 'm' must have the same length");let e=Array.from({length:n},(s,c)=>c).sort((s,c)=>o[s]-o[c]),a=e.map(s=>o[s]),f=e.map(s=>l[s]),r=e.map(s=>t[s]);for(let s=1;s<n;s++)if(!(a[s]-a[s-1]>0))throw new RangeError("'x' must be *strictly* increasing (non - NA)");return(s,c=0)=>L(a,f,r,s,c)}function V(o,l,t){let n=Array.from(o),e=Array.from(l),a=n.length;if(e.length!==a)throw new RangeError("'xi' and 'yi' must have the same length");let f=Array.from(t),r=Math.min(...n),s=Math.max(...n);if(f.some(i=>i<r||i>s))throw new RangeError("Some interpolation points outside the nodes.");let c=n.map((i,p)=>{let d=1;for(let h=0;h<a;h++)h!==p&&(d*=i-n[h]);return 1/d});return f.map(i=>{let p=0,d=0,h=n.lastIndexOf(i);if(h>=0)return e[h];for(let m=0;m<a;m++){let g=i-n[m],u=c[m]/g;p+=u*e[m],d+=u}return p/d})}function W(o,l,t,n){let e=Array.from(o),a=Array.from(l),f=Array.from(t),r=e.length;if(a.length!==r||f.length!==r)throw new RangeError("'xi', 'yi' and 'di' must have the same length");let s=e.flatMap(h=>[h,h]),c=2*r,i=a.flatMap(h=>[h,h]),p=[i[0]],d=i.slice();for(let h=1;h<c;h++){let m=[];for(let g=0;g<c-h;g++)h===1&&s[g+1]===s[g]?m.push(f[g>>1]):m.push((d[g+1]-d[g])/(s[g+h]-s[g]));p.push(m[0]),d=m}return Array.from(n,h=>{let m=p[c-1];for(let g=c-2;g>=0;g--)m=m*(h-s[g])+p[g];return m})}function Z(o,l,t,n=[],e={}){let a=e.method??"rk4";if(a!=="euler"&&a!=="rk2"&&a!=="rk4")throw new RangeError(`unknown method '${String(a)}'`);let f=[...n],r=o.length,s=(d,h)=>{let m=Array.from(t(d,h,f));if(m.length!==r)throw new RangeError(`The number of derivatives returned by func() (${m.length}) must equal the length of the initial conditions vector (${r})`);return m},c=(d,h,m)=>d.map((g,u)=>g+h*m[u]),i=[...o],p=[];if(l.length===0)return p;p.push([l[0],...i]);for(let d=1;d<l.length;d++){let h=l[d-1],m=l[d]-h,g=s(h,i);if(a==="euler")i=c(i,m,g);else if(a==="rk2"){let u=s(h+m,c(i,m,g));i=i.map((w,y)=>w+m*(.5*g[y]+.5*u[y]))}else{let u=s(h+m/2,c(i,m/2,g)),w=s(h+m/2,c(i,m/2,u)),y=s(h+m,c(i,m,w));i=i.map((b,A)=>b+m/6*(g[A]+2*u[A]+2*w[A]+y[A]))}p.push([l[d],...i])}return p}function _(o,l,t){let n=l.eps??1e-4,e=l.d??t,a=l.zeroTol??Math.sqrt(Number.EPSILON/7e-7),f=l.r??4;if(!(Number.isInteger(f)&&f>=1))throw new RangeError("'r' must be a positive integer");return{eps:n,r:f,h0:o.map(r=>Math.abs(e*r)+(Math.abs(r)<a?n:0))}}function k(o){let l=[...o];for(let t=1;t<l.length;t++){let n=4**t;for(let e=0;e<l.length-t;e++)l[e]=(l[e+1]*n-l[e])/(n-1)}return l[0]}function N(o,l,t){let n=[...o];return n[l]=n[l]+t,n}function $(o){let l=o.method??"Richardson";if(l!=="Richardson"&&l!=="simple")throw new RangeError(`unknown method "${String(l)}" (expected "Richardson" or "simple")`);return l}function tt(o,l,t={}){let n=[...l],e=n.length;if($(t)==="simple"){let s=t.eps??1e-4,c=o([...n]);return n.map((i,p)=>(o(N(n,p,s))-c)/s)}let{r:a,h0:f}=_(n,t,1e-4),r=[];for(let s=0;s<e;s++){let c=[],i=f[s];for(let p=0;p<a;p++){if(p>0&&Math.abs(c[p-1])<1e-20?c.push(0):c.push((o(N(n,s,i))-o(N(n,s,-i)))/(2*i)),Number.isNaN(c[p]))throw new RangeError(`func returned NaN at step ${i} from x`);i/=2}r.push(k(c))}return r}function nt(o,l,t={}){let n=[...l],e=n.length,a=Array.from(o([...n])),f=a.map(()=>new Array(e).fill(NaN));if($(t)==="simple"){let c=t.eps??1e-4;for(let i=0;i<e;i++){let p=o(N(n,i,c));a.forEach((d,h)=>f[h][i]=(p[h]-d)/c)}return f}let{r,h0:s}=_(n,t,1e-4);for(let c=0;c<e;c++){let i=a.map(()=>[]),p=s[c];for(let d=0;d<r;d++){let h=o(N(n,c,p)),m=o(N(n,c,-p));a.forEach((g,u)=>i[u].push((h[u]-m[u])/(2*p))),p/=2}a.forEach((d,h)=>f[h][c]=k(i[h]))}return f}function rt(o,l,t={}){if((t.method??"Richardson")!=="Richardson")throw new RangeError('hessian supports only method "Richardson"');let n=[...l],e=n.length,{r:a,h0:f}=_(n,t,.1),r=o([...n]),s=[];for(let i=0;i<e;i++){let p=[],d=f[i];for(let h=0;h<a;h++)p.push((o(N(n,i,d))-2*r+o(N(n,i,-d)))/d**2),d/=2;s.push(k(p))}let c=n.map(()=>new Array(e).fill(NaN));for(let i=0;i<e;i++){c[i][i]=s[i];for(let p=0;p<i;p++){let d=[],h=f[i],m=f[p];for(let g=0;g<a;g++){let u=N(N(n,i,h),p,m),w=N(N(n,i,-h),p,-m);d.push((o(u)-2*r+o(w)-s[i]*h**2-s[p]*m**2)/(2*h*m)),h/=2,m/=2}c[i][p]=c[p][i]=k(d)}}return c}export{X as approx,V as barylag,tt as grad,W as hermiteInterp,rt as hessian,H as integrate,nt as jacobian,Z as ode,T as optimize,G as spline,K as splinefun,U as splinefunH,D as uniroot};

package/dist/optim/localmin.d.ts

@@ -0,0 +1,16 @@
+/** Default tolerance .Machine$double.eps^0.25, as in R's optimize */
+export declare const LOCALMIN_TOL: number;
+export interface LocalMinResult {
+    /** Location of the minimum */
+    x: number;
+    /** f at x (the last value computed there) */
+    fx: number;
+    /** Number of evaluations of f */
+    evaluations: number;
+}
+/**
+ * A local minimum of f in [lower, upper], to within about 3 tol + 2 sqrt(eps) |x| (Brent's localmin).
+ *
+ * @param tol - Tolerance (default .Machine$double.eps^0.25).
+ */
+export declare function localMin(f: (x: number) => number, lower: number, upper: number, tol?: number): LocalMinResult;

package/dist/optim/localmin.js

@@ -0,0 +1,97 @@
+// One-dimensional minimisation without derivatives (localmin from Brent 1973, "Algorithms for Minimization without
+// Derivatives", chapter 5), the algorithm behind R's optimize(). Golden-section search combined with successive
+// parabolic interpolation. The procedure follows the ALGOL 60 procedure in Brent's book (the same as netlib's
+// fmin.f, public domain), written for rStats.js.
+/** Default tolerance .Machine$double.eps^0.25, as in R's optimize */
+export const LOCALMIN_TOL = Math.pow(Number.EPSILON, 0.25);
+/**
+ * A local minimum of f in [lower, upper], to within about 3 tol + 2 sqrt(eps) |x| (Brent's localmin).
+ *
+ * @param tol - Tolerance (default .Machine$double.eps^0.25).
+ */
+export function localMin(f, lower, upper, tol = LOCALMIN_TOL) {
+    const c = 0.5 * (3 - Math.sqrt(5));
+    const eps = Math.sqrt(Number.EPSILON);
+    let a = lower;
+    let b = upper;
+    let v = a + c * (b - a);
+    let w = v;
+    let x = v;
+    let d = 0;
+    let e = 0;
+    let fx = f(x);
+    let fv = fx;
+    let fw = fx;
+    let evaluations = 1;
+    const tol3 = tol / 3;
+    for (;;) {
+        const xm = 0.5 * (a + b);
+        const tol1 = eps * Math.abs(x) + tol3;
+        const t2 = 2 * tol1;
+        // stopping criterion
+        if (Math.abs(x - xm) <= t2 - 0.5 * (b - a))
+            break;
+        let golden = true;
+        if (Math.abs(e) > tol1) {
+            // fit a parabola through (v, fv), (w, fw), (x, fx)
+            let r = (x - w) * (fx - fv);
+            let q = (x - v) * (fx - fw);
+            let p = (x - v) * q - (x - w) * r;
+            q = 2 * (q - r);
+            if (q > 0)
+                p = -p;
+            else
+                q = -q;
+            r = e;
+            e = d;
+            if (Math.abs(p) < Math.abs(0.5 * q * r) && p > q * (a - x) && p < q * (b - x)) {
+                // parabolic interpolation step
+                d = p / q;
+                const u = x + d;
+                // f must not be evaluated too close to a or b
+                if (u - a < t2 || b - u < t2)
+                    d = x <= xm ? tol1 : -tol1; // sign(tol1, xm - x), + for 0
+                golden = false;
+            }
+        }
+        if (golden) {
+            // golden-section step
+            e = x < xm ? b - x : a - x;
+            d = c * e;
+        }
+        // f must not be evaluated too close to x
+        const u = Math.abs(d) >= tol1 ? x + d : d >= 0 ? x + tol1 : x - tol1; // x + sign(tol1, d)
+        const fu = f(u);
+        evaluations++;
+        // update a, b, v, w and x
+        if (fu <= fx) {
+            if (u < x)
+                b = x;
+            else
+                a = x;
+            v = w;
+            fv = fw;
+            w = x;
+            fw = fx;
+            x = u;
+            fx = fu;
+        }
+        else {
+            if (u < x)
+                a = u;
+            else
+                b = u;
+            if (fu <= fw || w === x) {
+                v = w;
+                fv = fw;
+                w = u;
+                fw = fu;
+            }
+            else if (fu <= fv || v === x || v === w) {
+                v = u;
+                fv = fu;
+            }
+        }
+    }
+    return { x, fx, evaluations };
+}

package/dist/random/as241.d.ts

@@ -0,0 +1,2 @@
+/** Standard normal quantile for 0 < p < 1 */
+export declare function ppnd16(p: number): number;

package/dist/random/as241.js

@@ -0,0 +1,58 @@
+// Standard normal quantile (PPND16 from Wichura 1988, Algorithm AS 241 "The percentage points of the
+// normal distribution", Applied Statistics 37(3)).
+//
+// Used only to transform uniforms into normal variates (inversion). As documented in ?qnorm, R's rnorm()
+// transforms uniforms with this algorithm, so computing with the same formulas gives the same variates as R
+// (qnorm in src/distributions/normal.ts uses a different algorithm and may differ in the last digit).
+// The p used for random numbers exceeds 2^-54, so only the range covered by the paper (r <= 27) is handled here.
+const A = [
+    3.387132872796366608, 133.14166789178437745, 1971.5909503065514427, 13731.693765509461125,
+    45921.953931549871457, 67265.770927008700853, 33430.575583588128105, 2509.0809287301226727,
+];
+const B = [
+    1, 42.313330701600911252, 687.1870074920579083, 5394.1960214247511077, 21213.794301586595867,
+    39307.89580009271061, 28729.085735721942674, 5226.495278852854561,
+];
+const C = [
+    1.42343711074968357734, 4.6303378461565452959, 5.7694972214606914055, 3.64784832476320460504,
+    1.27045825245236838258, 0.24178072517745061177, 0.0227238449892691845833, 7.7454501427834140764e-4,
+];
+const D = [
+    1, 2.05319162663775882187, 1.6763848301838038494, 0.68976733498510000455, 0.14810397642748007459,
+    0.0151986665636164571966, 5.475938084995344946e-4, 1.05075007164441684324e-9,
+];
+const E = [
+    6.6579046435011037772, 5.4637849111641143699, 1.7848265399172913358, 0.29656057182850489123,
+    0.026532189526576123093, 0.0012426609473880784386, 2.71155556874348757815e-5, 2.01033439929228813265e-7,
+];
+const F = [
+    1, 0.59983220655588793769, 0.13692988092273580531, 0.0148753612908506148525, 7.868691311456132591e-4,
+    1.8463183175100546818e-5, 1.4215117583164458887e-7, 2.04426310338993978564e-15,
+];
+/** c[7] r^7 + ... + c[0] by Horner's method */
+function poly(c, r) {
+    let s = c[7];
+    for (let i = 6; i >= 0; i--)
+        s = s * r + c[i];
+    return s;
+}
+/** Standard normal quantile for 0 < p < 1 */
+export function ppnd16(p) {
+    const q = p - 0.5;
+    if (Math.abs(q) <= 0.425) {
+        const r = 0.180625 - q * q;
+        return (q * poly(A, r)) / poly(B, r);
+    }
+    let r = q < 0 ? p : 1 - p;
+    r = Math.sqrt(-Math.log(r));
+    let val;
+    if (r <= 5) {
+        r -= 1.6;
+        val = poly(C, r) / poly(D, r);
+    }
+    else {
+        r -= 5;
+        val = poly(E, r) / poly(F, r);
+    }
+    return q < 0 ? -val : val;
+}

package/dist/random/beta.d.ts

@@ -0,0 +1,14 @@
+/** One beta variate (shape1 aa, shape2 bb) */
+export declare function rbeta1(aa: number, bb: number): number;
+/**
+ * Random numbers from the beta distribution. Equivalent to R's `rbeta()`.
+ *
+ * @param n Number of values to generate (fractions are truncated, as in R).
+ * @param shape1 First shape parameter.
+ * @param shape2 Second shape parameter.
+ * @param options.ncp Non-centrality parameter. If omitted, the central distribution is used.
+ * @returns An array of `n` values; `NaN` for invalid parameters.
+ */
+export declare function rbeta(n: number, shape1: number, shape2: number, options?: {
+    ncp?: number;
+}): number[];

package/dist/random/beta.js

@@ -0,0 +1,117 @@
+// Beta random variates.
+//
+// Cheng (1978) "Generating beta variates with nonintegral shape parameters"
+// (Comm. ACM 21(4)): algorithm BB (min(a, b) > 1) and BC (min(a, b) <= 1).
+// These are the algorithms cited in R's ?rbeta, with the constants from the paper. The order in which uniforms
+// are consumed and the parameter handling follow observed R output.
+import { unifRand } from "./rng.js";
+import { generate } from "./common.js";
+import { rchisq } from "./gamma.js";
+/** The value of log(DBL_MAX) (1024 log 2) */
+const EXPMAX = 1024 * Math.LN2;
+let beta = 0, gamma = 0, delta = 0, k1 = 0, k2 = 0;
+let olda = -1, oldb = -1;
+/** v = beta log(u1 / (1 - u1)) and w = aa e^v (DBL_MAX on overflow) */
+function vw(u1, aa) {
+    const v = beta * Math.log(u1 / (1 - u1));
+    if (v <= EXPMAX) {
+        let w = aa * Math.exp(v);
+        if (!Number.isFinite(w))
+            w = Number.MAX_VALUE;
+        return [v, w];
+    }
+    return [v, Number.MAX_VALUE];
+}
+/** One beta variate (shape1 aa, shape2 bb) */
+export function rbeta1(aa, bb) {
+    if (Number.isNaN(aa) || Number.isNaN(bb) || aa < 0 || bb < 0)
+        return NaN;
+    if (!Number.isFinite(aa) && !Number.isFinite(bb))
+        return 0.5;
+    if (aa === 0 && bb === 0)
+        return unifRand() < 0.5 ? 0 : 1;
+    if (!Number.isFinite(aa) || bb === 0)
+        return 1;
+    if (!Number.isFinite(bb) || aa === 0)
+        return 0;
+    const qsame = olda === aa && oldb === bb;
+    if (!qsame) {
+        olda = aa;
+        oldb = bb;
+    }
+    const a = Math.min(aa, bb);
+    const b = Math.max(aa, bb);
+    const alpha = a + b;
+    let v, w;
+    if (a <= 1) {
+        // Algorithm BC
+        if (!qsame) {
+            beta = 1 / a;
+            delta = 1 + b - a;
+            k1 = (delta * (0.0138889 + 0.0416667 * a)) / (b * beta - 0.777778);
+            k2 = 0.25 + (0.5 + 0.25 / delta) * a;
+        }
+        for (;;) {
+            const u1 = unifRand();
+            const u2 = unifRand();
+            let z;
+            if (u1 < 0.5) {
+                const y = u1 * u2;
+                z = u1 * y;
+                if (0.25 * u2 + z - y >= k1)
+                    continue;
+            }
+            else {
+                z = u1 * u1 * u2;
+                if (z <= 0.25) {
+                    [v, w] = vw(u1, b);
+                    break;
+                }
+                if (z >= k2)
+                    continue;
+            }
+            [v, w] = vw(u1, b);
+            if (alpha * (Math.log(alpha / (a + w)) + v) - 1.3862944 >= Math.log(z))
+                break;
+        }
+        return aa === a ? a / (a + w) : w / (a + w);
+    }
+    // Algorithm BB
+    if (!qsame) {
+        beta = Math.sqrt((alpha - 2) / (2 * a * b - alpha));
+        gamma = a + 1 / beta;
+    }
+    let r, t;
+    do {
+        const u1 = unifRand();
+        const u2 = unifRand();
+        [v, w] = vw(u1, a);
+        const z = u1 * u1 * u2;
+        r = gamma * v - 1.3862944;
+        const s = a + r - w;
+        if (s + 2.609438 >= 5 * z)
+            break;
+        t = Math.log(z);
+        if (s > t)
+            break;
+    } while (r + alpha * Math.log(alpha / (b + w)) < t);
+    return aa !== a ? b / (b + w) : w / (b + w);
+}
+/**
+ * Random numbers from the beta distribution. Equivalent to R's `rbeta()`.
+ *
+ * @param n Number of values to generate (fractions are truncated, as in R).
+ * @param shape1 First shape parameter.
+ * @param shape2 Second shape parameter.
+ * @param options.ncp Non-centrality parameter. If omitted, the central distribution is used.
+ * @returns An array of `n` values; `NaN` for invalid parameters.
+ */
+export function rbeta(n, shape1, shape2, options = {}) {
+    const { ncp } = options;
+    if (ncp === undefined)
+        return generate(n, () => rbeta1(shape1, shape2));
+    // Noncentral beta: as in R, generate n draws X ~ noncentral χ²(2 shape1, ncp), then n draws Y ~ χ²(2 shape2), and return X / (X + Y)
+    const x = rchisq(n, 2 * shape1, { ncp });
+    const y = rchisq(n, 2 * shape2);
+    return x.map((xi, i) => xi / (xi + y[i]));
+}

package/dist/random/binomial.d.ts

@@ -0,0 +1,25 @@
+/** One binomial variate (nin trials, success probability pp) */
+export declare function rbinom1(nin: number, pp: number): number;
+/**
+ * Random numbers from the binomial distribution. Equivalent to R's `rbinom()`.
+ *
+ * @param n Number of values to generate (fractions are truncated, as in R).
+ * @param size Number of trials.
+ * @param prob Probability of success in each trial.
+ * @returns An array of `n` values; `NaN` for invalid parameters.
+ */
+export declare function rbinom(n: number, size: number, prob: number): number[];
+/**
+ * Random vectors from the multinomial distribution. Equivalent to R's `rmultinom()`.
+ *
+ * Unlike R, which returns a K x n matrix with one draw per column, this returns `n` rows
+ * with one draw per row (the transpose of R's result). The random stream is the same as R's.
+ *
+ * @param n Number of values to generate (fractions are truncated, as in R).
+ * @param size Number of objects distributed into the K categories in each draw.
+ * @param prob Category weights of length K. They need not sum to 1 (they are divided by their sum).
+ * @returns An array of `n` arrays, each of length K and summing to `size`.
+ * @throws RangeError if `size` is not a non-negative integer, or `prob` has a negative or
+ *   non-finite value, or no positive value.
+ */
+export declare function rmultinom(n: number, size: number, prob: readonly number[]): number[][];

package/dist/random/binomial.js

@@ -0,0 +1,224 @@
+// Binomial and multinomial random variates.
+//
+// Kachitvichyanukul & Schmeiser (1988) "Binomial random variate generation"
+// (Comm. ACM 31(2)): algorithm BTPE. When n min(p, 1-p) < 30, inversion (BINV in the paper) is used.
+// These are the algorithms cited in R's ?rbinom, with the constants from the paper. The order in which uniforms
+// are consumed and the parameter handling follow observed R output.
+import { unifRand } from "./rng.js";
+import { generate, powInt } from "./common.js";
+import { qbinom } from "../distributions/binomial.js";
+const INT_MAX = 2147483647;
+// Values rebuilt only when the parameters change
+let c = 0, fm = 0, npq = 0, p1 = 0, p2 = 0, p3 = 0, p4 = 0, qn = 0;
+let xl = 0, xll = 0, xlr = 0, xm = 0, xr = 0;
+let psave = -1, nsave = -1, m = 0;
+/** Correction term of Stirling's formula (13860 - (462 - (132 - (99 - 140/z²)/z²)/z²)/z²)/z/166320 */
+function stirlingTail(z) {
+    const z2 = z * z;
+    return (13860 - (462 - (132 - (99 - 140 / z2) / z2) / z2) / z2) / z / 166320;
+}
+/** One binomial variate (nin trials, success probability pp) */
+export function rbinom1(nin, pp) {
+    if (!Number.isFinite(nin))
+        return NaN;
+    const rn = Math.round(nin);
+    if (rn !== nin)
+        return NaN;
+    if (!Number.isFinite(pp) || rn < 0 || pp < 0 || pp > 1)
+        return NaN;
+    if (rn === 0 || pp === 0)
+        return 0;
+    if (pp === 1)
+        return rn;
+    if (rn >= INT_MAX)
+        return qbinom(unifRand(), rn, pp, { lowerTail: false });
+    const n = rn;
+    const p = Math.min(pp, 1 - pp);
+    const q = 1 - p;
+    const np = n * p;
+    const r = p / q;
+    const g = r * (n + 1);
+    let small;
+    if (pp !== psave || n !== nsave) {
+        psave = pp;
+        nsave = n;
+        if (np < 30) {
+            qn = powInt(q, n);
+            small = true;
+        }
+        else {
+            small = false;
+            fm = np + p;
+            m = Math.trunc(fm);
+            npq = np * q;
+            p1 = Math.trunc(2.195 * Math.sqrt(npq) - 4.6 * q) + 0.5;
+            xm = m + 0.5;
+            xl = xm - p1;
+            xr = xm + p1;
+            c = 0.134 + 20.5 / (15.3 + m);
+            let al = (fm - xl) / (fm - xl * p);
+            xll = al * (1 + 0.5 * al);
+            al = (xr - fm) / (xr * q);
+            xlr = al * (1 + 0.5 * al);
+            p2 = p1 * (1 + c + c);
+            p3 = p2 + c / xll;
+            p4 = p3 + c / xlr;
+        }
+    }
+    else {
+        small = np < 30;
+    }
+    let ix;
+    if (small) {
+        // Inversion (mean below 30)
+        outer: for (;;) {
+            ix = 0;
+            let f = qn;
+            let u = unifRand();
+            for (;;) {
+                if (u < f)
+                    break outer;
+                if (ix > 110)
+                    break;
+                u -= f;
+                ix++;
+                f *= g / ix - r;
+            }
+        }
+    }
+    else {
+        for (;;) {
+            const u = unifRand() * p4;
+            let v = unifRand();
+            // Triangular region
+            if (u <= p1) {
+                ix = Math.trunc(xm - p1 * v + u);
+                break;
+            }
+            if (u <= p2) {
+                // Parallelogram region
+                const x = xl + (u - p1) / c;
+                v = v * c + 1 - Math.abs(xm - x) / p1;
+                if (v > 1 || v <= 0)
+                    continue;
+                ix = Math.trunc(x);
+            }
+            else if (u > p3) {
+                // Right tail
+                ix = Math.trunc(xr - Math.log(v) / xlr);
+                if (ix > n)
+                    continue;
+                v = v * (u - p3) * xlr;
+            }
+            else {
+                // Left tail
+                ix = Math.trunc(xl + Math.log(v) / xll);
+                if (ix < 0)
+                    continue;
+                v = v * (u - p2) * xll;
+            }
+            // Acceptance/rejection test
+            const k = Math.abs(ix - m);
+            if (k <= 20 || k >= npq / 2 - 1) {
+                // Compute the probability ratio directly
+                let f = 1;
+                if (m < ix) {
+                    for (let i = m + 1; i <= ix; i++)
+                        f *= g / i - r;
+                }
+                else if (m > ix) {
+                    for (let i = ix + 1; i <= m; i++)
+                        f /= g / i - r;
+                }
+                if (v <= f)
+                    break;
+            }
+            else {
+                // Squeeze using upper and lower bounds on log f
+                const amaxp = (k / npq) * ((k * (k / 3 + 0.625) + 0.1666666666666) / npq + 0.5);
+                const ynorm = (-k * k) / (2 * npq);
+                const alv = Math.log(v);
+                if (alv < ynorm - amaxp)
+                    break;
+                if (alv <= ynorm + amaxp) {
+                    // Final test using Stirling's formula (M is the integer mode m)
+                    const x1 = ix + 1;
+                    const f1 = m + 1;
+                    const z = n + 1 - m;
+                    const w = n - ix + 1;
+                    if (alv <=
+                        xm * Math.log(f1 / x1) +
+                            (n - m + 0.5) * Math.log(z / w) +
+                            (ix - m) * Math.log((w * p) / (x1 * q)) +
+                            stirlingTail(f1) +
+                            stirlingTail(z) +
+                            stirlingTail(x1) +
+                            stirlingTail(w)) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (psave > 0.5)
+        ix = n - ix;
+    return ix;
+}
+/**
+ * Random numbers from the binomial distribution. Equivalent to R's `rbinom()`.
+ *
+ * @param n Number of values to generate (fractions are truncated, as in R).
+ * @param size Number of trials.
+ * @param prob Probability of success in each trial.
+ * @returns An array of `n` values; `NaN` for invalid parameters.
+ */
+export function rbinom(n, size, prob) {
+    return generate(n, () => rbinom1(size, prob));
+}
+/**
+ * Random vectors from the multinomial distribution. Equivalent to R's `rmultinom()`.
+ *
+ * Unlike R, which returns a K x n matrix with one draw per column, this returns `n` rows
+ * with one draw per row (the transpose of R's result). The random stream is the same as R's.
+ *
+ * @param n Number of values to generate (fractions are truncated, as in R).
+ * @param size Number of objects distributed into the K categories in each draw.
+ * @param prob Category weights of length K. They need not sum to 1 (they are divided by their sum).
+ * @returns An array of `n` arrays, each of length K and summing to `size`.
+ * @throws RangeError if `size` is not a non-negative integer, or `prob` has a negative or
+ *   non-finite value, or no positive value.
+ */
+export function rmultinom(n, size, prob) {
+    if (!Number.isFinite(size) || size < 0 || Math.round(size) !== size)
+        throw new RangeError("size must be a non-negative integer");
+    let sum = 0;
+    for (const v of prob) {
+        if (!Number.isFinite(v) || v < 0)
+            throw new RangeError("prob must contain non-negative finite numbers");
+        sum += v;
+    }
+    if (sum === 0)
+        throw new RangeError("prob must contain at least one positive value");
+    const pr = prob.map((v) => v / sum);
+    const K = pr.length;
+    const draw = () => {
+        const out = new Array(K).fill(0);
+        let left = size;
+        let pTot = 1;
+        for (let k = 0; k < K - 1; k++) {
+            if (pr[k]) {
+                const pk = pr[k] / pTot;
+                out[k] = pk < 1 ? rbinom1(left, pk) : left;
+                left -= out[k];
+            }
+            if (left <= 0)
+                return out;
+            pTot -= pr[k];
+        }
+        out[K - 1] = left;
+        return out;
+    };
+    if (!Number.isFinite(n) || n < 0)
+        throw new RangeError("n must be a non-negative finite number");
+    return Array.from({ length: Math.trunc(n) }, draw);
+}

package/dist/random/common.d.ts

@@ -0,0 +1,4 @@
+/** Generate n random values. As in R, n must be non-negative (fractions are truncated) */
+export declare function generate(n: number, f: () => number): number[];
+/** Integer power x^n (by repeated squaring; Math.pow is not used, to round the same way as R's generators) */
+export declare function powInt(x: number, n: number): number;

package/dist/random/common.js

@@ -0,0 +1,35 @@
+// Shared helpers for the r functions.
+/** Generate n random values. As in R, n must be non-negative (fractions are truncated) */
+export function generate(n, f) {
+    if (!Number.isFinite(n) || n < 0)
+        throw new RangeError("n must be a non-negative finite number");
+    const len = Math.trunc(n);
+    const out = new Array(len);
+    for (let i = 0; i < len; i++)
+        out[i] = f();
+    return out;
+}
+/** Integer power x^n (by repeated squaring; Math.pow is not used, to round the same way as R's generators) */
+export function powInt(x, n) {
+    let pow = 1;
+    if (Number.isNaN(x))
+        return x;
+    if (n !== 0) {
+        if (!Number.isFinite(x))
+            return Math.pow(x, n);
+        if (n < 0) {
+            n = -n;
+            x = 1 / x;
+        }
+        for (;;) {
+            if (n & 1)
+                pow *= x;
+            n >>= 1;
+            if (n)
+                x *= x;
+            else
+                break;
+        }
+    }
+    return pow;
+}