Revision history for Stats-LikeR 0.3422 2026-11-13 CST (Claude Fable 5.2 helped) [view()] - view() is now written in C. It was a Perl sub that built an array for every cell and called three or four closures on it. The table is unchanged: 25000 random frames and option lists, of every shape and with UTF-8, Latin-1, wide characters, NULs, escapes and cut cells in them, came out byte for byte the same from both. - What that did to its time and memory, on perl 5.44.0 and frames of ten columns, six of numbers and four of strings, is in the table below. Showing every row is 61 to 75 times faster, 29 times for a HoH, and takes between a seventh and an eighth of the memory. Six rows of a small frame are 5 to 12 times faster. Six rows of a million are slower than they were unless size => 0 is given, by the time it takes to find the size, and a HoH, whose keys the Perl sorted, takes as long as it did. With size => 0 they are 50 to 71 times faster, and a HoH 6 times. In the table "Perl" is view() as 0.3421 had it, "C" is view() as it is now, and "size=>0" is the C without the size described below, which is the work the Perl did. A time is the fastest call seen in three processes. A peak is how far the call raised the process's peak resident memory, in MB of 1024 kB, and 0 is less than 0.1 MB. All 100000 rows of a 100000-row frame, a table of 15 MB frame Perl ms C ms size=>0 ms Perl MB C MB size=>0 MB AoA 7867 104 99 438 58 58 AoH 7941 131 124 453 58 58 HoA 7900 108 98 445 58 58 HoH 8202 287 228 469 66 66 The default six rows of a 1000-row frame frame Perl ms C ms size=>0 ms Perl MB C MB size=>0 MB AoA 0.424 0.044 0.006 0 0 0 AoH 0.446 0.084 0.009 0 0 0 HoA 0.445 0.036 0.007 0 0 0 HoH 0.686 0.134 0.031 0 0 0 The default six rows of a 1000000-row frame frame Perl ms C ms size=>0 ms Perl MB C MB size=>0 MB AoA 0.424 46.8 0.006 0 0 0 AoH 0.444 100 0.009 0 0 0 HoA 0.444 116 0.007 0 0 0 HoH 744 721 127 115 0 0 - The first line now says how much memory the data takes: "# AoH: 7 rows x 3 cols, 2.9 KB (showing 6)", with the tab it has always had before "(showing". It is everything that can be reached from the reference, as perl has allocated it, with a key the rows of an AoH share, a row or column held twice and a copy-on-write string each counted once. What a code reference, a glob or a weak reference leads to is not counted, and a tied structure is not fetched from. The size is written as pandas' DataFrame.info() writes a memory usage, in units of 1024 with one decimal: "152.0 bytes", "22.5 KB", "1.4 GB". Against Devel::Size 0.87 the count differs by 8 bytes for every string and by nothing else on 200000-row frames, and the 8 are a stale row in that module's table of body sizes. - The size is the whole frame's, so it means visiting every cell: 0.05 s for a million rows of ten columns as an AoA, 0.10 s as an AoH and 0.12 s as a HoA, where the rest of view() takes under a tenth of a millisecond. The new option size => 0 leaves the size out and the visit with it, and view() of such a frame is then 50 to 71 times faster than it was. - A HoH's rows are found without sorting every key. Showing six rows of 500000 took 332 ms and 59 MB for the list of keys, and takes 56 ms and no memory to speak of with size => 0. - view() leaves nothing on the frame. The Perl's keys() left an iterator on every row it read the columns off, 120 bytes each on perl 5.44.0: 12 MB after showing 100000 rows of an AoH. An each() in progress on a row or on the frame is no longer reset either. - A hash with an array among its values is a HoA, whichever value perl's hash order puts first. The Perl let the first defined value decide, so a HoA that also held a scalar, which assign() documents, was shown as a HoA on one run and as a one-row hash of ARRAY(0x...) cells on another. A hash with a hash among its values and no array is a HoH, and one with neither is a flat hash, as before. - An odd option list, an undef option name, a `cols` that is not an array reference, an undef name in it and a `colors` that is not a hash reference now die with view's help screen. They used to die on whichever line of the module first tripped over them, with perl's own message. max_width and gap are now checked as n and width always were, so a negative or fractional one is refused where it used to give a garbled table or be truncated, and gap => undef is the default gap where it died with "uninitialized value". - An ellipsis given as UTF-8 bytes, a literal "…" in a file without `use utf8`, is no longer encoded a second time and counted as three columns. - A table printed to a handle with a :utf8 or :encoding layer is no longer encoded twice. The table is UTF-8 bytes, and print upgraded them again on such a handle, so "Jørgensen" came out as mojibake. The string view() returns is unchanged. - t/view.size.t is new: the size's format against 643 results of pandas 3.0.4's own _sizeof_fmt(), frozen in the file and crossing every unit, every exact tie in the tenths and the counts past 1024 PB, and what must hold of the count on every perl (754 subtests). t/view.xs.t is new too: a HoH's row order against perl's sort for keys that mix Latin-1 and UTF-8, the argument errors, tied and overloaded cells, where the table is printed, and leak checks through each croak (201 subtests). Five tests in t/view.t and t/view2.t that matched the whole first line now allow for the size. - The first line says what it is counting: "(showing 6 rows)", and "(showing 1 row)" for one, where it said "(showing 6)". The count is the same. - That first line is printed again as the last, after the "# ... N more rows" line when there is one, so that a table longer than the screen still says what it is, how big it is and how much of it was shown where the scrolling stops. The tests in t/view.t, t/view2.t, t/view_aoa.t, t/view.aoa.t, t/view.xs.t and t/view.size.t that counted lines or read the last one now expect it. [summary()] - summary() prints through the same C renderer, so its table is unchanged and no size is added to it. Its first line now ends in "(showing N rows)" as view()'s does, but it is not repeated at the bottom: a summary is a few lines long. Its display options are now checked in its own name: a width, max_width or gap that is not a whole number, or a `colors` that is not a hash reference, dies with summary's help screen where it used to die inside the renderer with perl's "isn't numeric". gap => undef is the default gap. [read_table()] - New option drop_cols: a column name, a qr// regex, or an array reference holding any mix of the two, and a column with one of the names, or whose name matches one of the patterns, is left out of the table as the file is read. Its cells are never made, so a wide file costs the memory of the columns that are kept. On a 200000 x 40 CSV of 72 MB, leaving out 30 columns took an aoh from 0.61 s and 764 MB of peak memory growth to 0.20 s and 138 MB, a hoa from 0.47 s and 528 MB to 0.14 s and 64 MB, and an aoa from 0.42 s and 544 MB to 0.15 s and 84 MB, on perl 5.44.0. - A name is a whole column name, compared exactly: case-sensitive, never a prefix, and with a '.', '(' or '|' in it meaning that character. A number is a name too, never a field position, and '' is the column whose name is empty. A name that is no column is warned about, as R's read.table() warns of a colClasses name: "not all columns named in 'drop_cols' exist", followed by the file and the missing names. The read goes on without them. - Names and patterns are matched against the names the table would have had: after col_names, with V1, V2, ... under header => 0, and with a VCF's leading "#" off. A header name is tried as the bytes the file holds and, when they are UTF-8, as the characters they spell, so a name or pattern written under `use utf8` and one written without it both match. It works for every output_type, for .xlsx sheets and for compressed files, and where the header repeats a name every field carrying it goes. A colClasses list, a numeric filter key and the field number in an alignment message still count the file's own fields, and a filter may test a column that is left out. - A pattern that matches no column is not an error, and is not warned about, since one list of patterns often serves several files. Leaving out every column is an error, and so is leaving out the row_names column of a hoh. drop_cols is refused for an exploded VCF, whose columns are built by position; explode => 0 reads the file's own columns. - drop_cols => qr// is every column, on every perl. Before perl 5.18 the match operator does not match an empty qr// as it is written: it reuses the last pattern that matched successfully, so on perl 5.10.1, 5.12.5 and 5.16.3 an empty pattern left out whichever columns that other pattern happened to match, and no column at all of an .xlsx sheet. An empty pattern is now exchanged for one that is not empty before it is matched, without compiling anything on the call. - t/read_table.drop_cols.t is new (1865 subtests): every output type by the parser's plan and by the row closure, which check each other, on delimited text, .gz, .xlsx and VCF, with colClasses, filters, repeated names, UTF-8 names and ragged rows, the empty pattern after an unrelated match, each refusal, and leak checks. - New option keep_cols, the counterpart of drop_cols: it takes the same names and patterns, and only the columns it names or matches are stored, in the file's order, as pandas' read_csv(usecols = ...) keeps them. A name that is no column is warned about rather than raised on as pandas does, and keeping no column is an error. A hoh's row_names column is its key and never a cell, so it is kept whether keep_cols names it or not. Given together, a column is stored when keep_cols chooses it and drop_cols does not. - t/read_table.keep_cols.t is new (1512 subtests). It ports every name-based case of pandas 3.0.4's tests/io/parser/usecols/test_usecols_basic.py and test_strings.py, pins each place read_table departs from them, and holds the rest to the row closure and, on a 600 x 40 table, to drop_cols given the complement. [filter()] - col()->match and ->nomatch with an empty pattern, qr// or the string '', now match every defined cell on every perl, as grepl("", x) does in R and str.contains("") in pandas. Before perl 5.18 they matched whatever pattern had last matched successfully instead, for the reason given under read_table() above: col('id')->match(qr//) kept one row of four in t/filter_match.t on perl 5.10.1 and 5.16.3 where it should have kept all four. cfilter()'s regex selector and read_table()'s qr// separator match in C, where there is no such rule, and are unchanged. 0.3421 2026-11-13 CST (Claude Fable 5.2 helped) [qnorm(), qt(), qchisq()] - A probability at an end of its range is now answered before the distribution parameter is validated, which is the order R takes them in. qnorm(0, 0, -1) is -Inf and qnorm(1, 0, -1) is Inf; qt(0, -1) is -Inf and qt(1, 0) is Inf; qchisq(0, -1) is 0 and qchisq(1, -1) is Inf. The same holds for a log probability of -Inf or 0 and for the upper tail. Up to 0.342 every one of these was NaN, because the sd or df was checked first. R's qnorm.c, qt.c and qgamma.c (which qchisq calls) run R_Q_P01_boundaries() ahead of the parameter check; R 4.6.1's source was read for the order, and R 4.6.2 run for the values. - Nothing else moves. An invalid parameter with a probability inside the range is still NaN, as is a NaN parameter anywhere. qf() is unchanged and has no such exception: R's qf.c checks df1 and df2 first, so qf(0, -1, 2) is NaN there and here. SciPy validates the parameters first in all of these and returns nan; this module follows R. - t/distributions.q.ends.R.t is new: a frozen table of 388 R results crossing both tails, both scales, the two ends and an interior p with invalid, degenerate and NaN parameters, each called positionally, by name and through an array reference (927 subtests). 104 of its rows fail against 0.342. [mode()] - mode() is faster and lighter where values repeat. Its counts are now one array of integers in place of one perl scalar per distinct value. On 1e6 values holding 100 distinct integers a call went from 40.6 ms to 31.9 ms, and with 100 distinct strings from 29.7 ms to 22.3 ms; with every value distinct the gain is 3%. With 1e6 distinct integers the call's peak memory growth fell from 231 MB to 207 MB. The results are unchanged, ties still coming back in first-seen order. - t/mode.scipy.t is new: the one-dimensional cases of SciPy's own TestMode, and inputs on both sides of each point where the count array grows, with leak checks, one of them through a croak. 0.342 2026-11-10 CST (Claude Fable 5.2 helped) [Out-of-memory guards: 11 failing reports of 0.3419] - 0.3419 failed on 11 of its 36 CPAN Testers reports, all in t/alloc.guards.t and nowhere else: perl 5.24.4 and 5.44.0 on x86_64 and aarch64 Linux (gcc 15.2 and 16.1), GNU/Hurd, NetBSD and DragonFly, and 5.44.0 on aarch64-android (clang). The test exited with "Out of memory!" or "Out of memory in perl:util:safesyscalloc", or was killed, after its 15th or 16th subtest. The module and the test were each at fault. - The module: alloc_probe_ok(), which lets matrix(), runif(), rnorm(), fisher_test(), mcnemar_test(), dunn_test() and the bw_*() selectors croak when the memory they need is not there, asked malloc() for the block and freed it untouched. A compiler may delete such a pair and treat the request as granted, and the guard then never fires. That is the reading that fits the Linux and Android reports, where an allocation half the size of the one just "probed" was refused; it was not observed directly, since gcc 13.3 and 14.2 keep the call, but a build with the probe removed dies exactly as the Android report does. The probe now writes one byte to the block through a volatile lvalue, which a compiler has to keep. - The test: three cases asked the machine for 16 GB, 320 GB and 22 TB and assumed it would refuse. A system that overcommits grants the request and kills the process when the pages are touched, which is what NetBSD and DragonFly did, and where 16 GB was granted bw_sj(nb => 2**31 - 1) alone ran 150 s. Those three cases now run only under EXTENDED_TESTING or AUTHOR_TESTING. In their place runif(2**48) and rnorm(n => 2**48) ask for more address space than a process has, so the probe is exercised with the same answer on every machine; against a probe that always says yes they exit with "Out of memory". t/alloc.guards.t now has 23 subtests. 0.3419 2026-11-10 CST (Claude Fable 5.2 helped) [lm(), glm() and the formula models] - A term whose name is UTF-8 now finds its column. `use utf8; lm(formula => 'y ~ é', data => {y => [...], "é" => [...]})` died with "0 degrees of freedom", because the formula's bytes were fetched as a byte key. The name is now also tried as a UTF-8 key, for hash-of-arrays and array-of-hashes data, in lm(), glm(), predict() and the other models that read columns this way. The coefficient names are still the formula's own bytes, without the UTF-8 flag. - A tied scalar inside a data column was read as missing, because the element's definedness was tested before its FETCH ran. It is now fetched first, and once. - Terms with arithmetic inside parentheses were split at the '+', '*' or '/' inside them: `y ~ log(x+1)`, `I(x+z)`, `I(x*2)` and `exp(x/10)` died with "0 degrees of freedom", and `log(x^2)` lost its exponent. Terms are now split only at parenthesis depth 0, and I(), log(), exp(), sqrt(), log2(), log10(), log1p() and abs() evaluate + - * / ^ and nested parentheses with R's precedence. Coefficients match R's lm(). A term that cannot be read now dies with "lm: cannot evaluate term 'poly(x,2)'" instead of becoming an all-NaN column; a column that is all undef keeps its old message. A bare group of terms such as (a + b)*c is refused the same way: R expands it to a + b + c + a:c + b:c, which is not done here. [predict()] - predict() on a svyglm() fit with family quasibinomial or quasipoisson returned the linear predictor for type => 'response'. It now applies the inverse link, matching R's survey::svyglm. [zerotrunc(), hurdle()] - A negative binomial fit whose counts are in the thousands never met its convergence test: zerotrunc(dist => 'negbin') on 21 rows at mean 8000 ran 8.6 s and returned converged = 0 after 500 iterations, and 200 such rows did not finish in 100 s. The log-likelihood is a sum of terms of order y log y, so its rounding noise (about 2e-10 there) exceeded the 1e-12 * (|ll| + 1) bound used both to accept a Newton step and to stop, and every step was halved and rejected. Both tests now add a noise floor of 4 * NV_EPSILON times the sum of the terms' sizes. The same fits converge in 5 or 6 iterations, with coefficients, theta and loglik matching countreg and pscl. - The lgamma, digamma and trigamma differences of the negative binomial were summed term by term, O(y) per observation per evaluation. For y >= 64 and theta <= 10 y they are now taken as differences of the functions themselves, which agree with mpmath to 7e-15 relative; the term sum is kept for small y and for theta above 10 y, where those differences would cancel. [lmer()] - A nesting of three or more levels, as in (1 | a/b/c), was split at the first '/' only, giving a and a:b/c; the second names no column, every row was dropped, and the call died with "not enough complete observations". It now expands to (1 | a) + (1 | a:b) + (1 | a:b:c), as lme4 does, and (1 | a:b/c) gives a:b and a:b:c. Random slopes work the same way. A trailing or leading '/' is refused with "empty grouping factor". [csort()] - Integer columns above 2**53 now sort exactly. The sort keyed on an NV, so 64-bit ids such as 1800000000000000003, ...001, ...002 compared equal and kept their input order, in AoH, AoA and HoA input alike, as did numeric strings like '9223372036854775807'. Runs of equal keys at or above 2**53 are now re-ordered by exact IV/UV comparison, as perl's sort { $a <=> $b } orders them. Ordinary columns sort at the same speed. [min(), max()] - An integer extreme above 2**53 is returned exactly. max(9007199254740993, 9007199254740992, 12345678901234567) gave 1.23456789012346e+16 and now gives 12345678901234567. Ordinary doubles take the same path as before, at the same speed. Tied arrays and overloaded elements still return an NV. [sum()] - sum([1e308, 1e308, -1e308]) was Inf because the running total overflowed; R, with its long double accumulator, gives 1e308. When the total ends infinite a second pass scales each value by an exact power of two, so the result is exact and a true overflow stays Inf. [qnorm()] - Near the median the quantile lost digits: qnorm(0.5 + 1e-10) was 2.5066284462393505e-10 where R gives 2.5066284820303544e-10. The Newton residual pnorm(z) - p subtracted two numbers near 0.5 and rounded to 0, leaving the start value, built on a truncated sqrt(2*pi), uncorrected. For |p - 0.5| < 0.3 the residual is now formed from the series for Phi(z) - 0.5 against the exact p - 0.5. Results agree with R to 2 ulp across p = 0.5 +- 2^-k. [pbinom()] - A size above LONG_MAX (2147483647 where long is 32 bits, as on Windows) was NaN. pbinom(5, 1e19, 1e-18) is now 0.0670859628790321, as in R, in lower, upper and log form. [mcnemar_test(), dunn_test()] - mcnemar_test(exact => 1) now evaluates 2 * pbinom(min(b, c), b + c, 0.5) through the incomplete beta, as R's binom.test does, instead of summing b + c terms. At b = 29990000, c = 30010000 the old sum was off by 1.4e-7 relative and took 0.9 s; it now agrees with R to 1e-15 at once, and no longer casts the counts to long. - A mcnemar_test() table of many distinct labels (r * r cells), and a dunn_test() with more groups than its k * (k - 1) / 2 comparisons can be allocated for, croak instead of aborting perl with "Out of memory". [bw_ucv(), bw_bcv(), bw_sj(), bw_nrd0(), bw_nrd()] - nb is validated as R's as.integer() does: a value above 2147483647 is "invalid 'nb'" (an nb of 2**32 truncated to 0 on a perl with a 32-bit size_t and wrote out of bounds), and an nb whose tables cannot be allocated croaks rather than aborting. - bw_nrd0() and bw_nrd() refuse a trailing option name with no value. [cor(), cov(), cor_test()] - All three ran a tied or overloaded cell's get magic twice, and could test one value and use another. It runs once now. - cov() and cor_test() leaked their number buffers when a cell's FETCH died (35 MB over 3000 calls at n = 1000 for cov()); they are now freed with the save stack, as cor()'s are. cor_test() also read a tied cell's definedness before its FETCH. - cor_test() accepted a bogus alternative and echoed it back, and conf_level 5, -1 or NaN returned nonsense limits. Both are refused as R's cor.test and t_test() refuse them. - cor() on a matrix with rows of unequal length took its width from row 0, read a short row's missing cells as NaN and ignored a long row's extra cells. It now croaks "x rows have unequal lengths", and likewise for y, as prcomp() does. [prcomp()] - scale => 1 refused any column whose standard deviation was at most an absolute 1e-15, so a column in small units (x * 1e-20) died with "cannot rescale a constant/zero column" where R returns sdev 1.1632, 0.8043. Only an exactly-zero scale is refused now, as in R. A column of equal values is centered on that value exactly, so its scale is exactly 0 and it is still refused. [epi_2x2(), cmh_test()] - A trailing option name with no value was silently dropped, so cmh_test($strata, 'correct') ran with the default. It is now refused with "options must be key => value pairs", as in survfit(). [fisher_test()] - A 2x2 table is handled in a window around the mode of the noncentral hypergeometric rather than over its whole support, so time and memory scale with the standard deviation, not the table total. fisher_test([[n, 1.1n], [1.05n, n]]) took 0.09 s, 0.89 s and 10.7 s at n = 1e5, 1e6 and 1e7 and now takes 0.011 s, 0.040 s and 0.20 s; peak memory at 1e7 fell from 332 MB to 25 MB. The window is found for every odds ratio the root-finders try, and its cutoff comes from the NV's own range. Results are bit-identical on the tables checked. - fisher_test([[5e8, 5e8], [5e8, 5e8]]) aborted the interpreter under a memory limit; it now answers, and what is still allocated goes through a croaking helper. - An r x c table sorts a node's pasts with a stable merge sort of the new tail and a linear merge into the sorted prefix, instead of re-sorting the whole list with qsort(): a 5x5 table takes 0.59 s instead of 0.79 s, with a bit-identical p-value. [wilcox_test()] - exact => 1 refuses up front a problem whose total count, C(m+n, m) or 2^n, is past the largest NV, with the same message as before, instead of running the recurrence first: 3000 against 3000 took 11.6 s to croak and now croaks at once. No input that succeeded before is refused. [sample()] - The index array is used from n >= count/20 instead of count/4. Between count/16 and count/4 the hash table was both slower and larger (count = 2e6, n = 499999: 0.0685 s and 50.9 MB against 0.0447 s and 33.9 MB). Draws for a given srand seed are unchanged. [svyglm()] - The per-stratum variance loop scanned every PSU once per stratum: 32000 strata took 1.2 s and 100000 took 11 s. The PSUs are now counting-sorted by stratum, giving 0.15 s and 0.5 s. The accumulation order is unchanged, so results are bit-identical. [logrank_test()] - The variance matrix was updated for every group pair at every event time: 20000 event times and 1000 groups took 10.6 s. An off-diagonal term only changes when a group loses a subject, so each pair is now settled against a running sum of c / n^2, in 0.46 s. Observed and expected are unchanged; the statistic moves by rounding only, about 1e-15 relative. [get_union(), intersection(), Lonly(), Ronly(), is_equivalent()] - These keyed each element with SvPV() on the caller's own SV, which formats a plain number and leaves the string cached on it for good: Lonly() of two 1e6-element double arrays grew the process by 304 MB that was never returned. They now use uniq()'s key table and render a bare number into a stack buffer. On 1e6 doubles get_union() went from 1.48 s and +466 MB to 0.41 s and +61 MB. Results are unchanged, except that returned copies of numbers are plain IV/NV rather than PVNV with a cached string. [survfit()] - A numeric group => column had a string cached on every cell, about 38 MB per million rows. The label is now rendered without touching the cell. [group_by()] - The mortal key made for each filter of each row lived until the call returned, about 16 bytes per row per filter. Each row now has its own tmps scope. [hoh2hoa()] - The output column's array is found once per column instead of by a hash lookup for every cell, about 7% on 200000 rows x 10 columns. [read_table()] - An .xlsx text node holding many '&' and no ';' was read in quadratic time, because every '&' scanned the whole remainder for a ';' (4e5 '&' in one cell took 0.84 s). The search now stops at the next '&', in 0.007 s. What is decoded is unchanged. - A .gz or .bz2 file is now read a block at a time, as documented. It was not: each 64 KB block of decompressed text was left as a temporary until the whole file had been parsed, so a compressed read held the entire decompressed text on top of the table. A filtered read that kept 20,475 of a 400 MB CSV's 7.8 million rows peaked at 30 MB from the plain file and at 422 MB from its .gz; a 13 MB CSV keeping 300 rows peaked at 14.2 MB from its .gz and now peaks at 2.2 MB (17.4 MB to 5.1 MB from its .bz2). The blocks are freed as each line is read. What is returned is unchanged. - Cells of one column that hold the same text now share one string in a CSV or TSV read, as an .xlsx's shared strings already did, so a column of categories costs one buffer per value instead of one per cell. A 300,000-row CSV with four category columns of six went from 233 MB to 197 MB as an aoh and from 140 MB to 103 MB as a hoa, and about 10% faster (0.109 s to 0.092 s as a hoa). A column whose cells do not repeat is noticed and left alone: a 30,000 x 50 file of distinct numbers reads in the same time to within 2 ms. The values are unchanged, and a write to one cell reaches no other; on perls before 5.18 Internals::SvREADONLY() is true of a shared cell, as it already was of an .xlsx's. Not for a read with a 'filter', whose rows are built as before. - A field that is an integer written as perl prints one ("42", "-7", "0") is now stored as that integer rather than as its text, in every kind of read: delimited, .xlsx, filtered, and the values of an exploded VCF. It takes 24 bytes where the text took about 72. A 300,000 x 6 CSV of counts read as a hoa went from 140 MB to 57 MB and from 0.110 s to 0.061 s; a 300,000 x 5 CSV with one id column from 106 MB to 92 MB. The cell prints as the bytes the file held, so eq, hash keys, regexes, sort and write_table() see no difference. What does change is anything that looks at a scalar's type: a JSON encoder now writes 5 where it wrote "5". Text an integer would not print back as is left alone: "007", "+5", "-0", "5.0", "1e3", " 5", and a number outside perl's integer range, which is not made a float. colClasses => 'character' keeps a column, or every column, as text; until now 'character' and no class at all meant the same. [write_table()] - LaTeX output is written as the records arrive instead of being copied into SVs first: a 20 x 200000 table of doubles peaked at 487 MB and now peaks at 153 MB, as csv does. The bytes written are unchanged, and a table with no columns is still refused before the file is opened. A croak from the data after the header (a tied cell whose FETCH dies) now leaves the partial file, as csv and .xlsx already did, where the old file was previously left untouched. - An .xlsx sheet now has its top row frozen by default, so the header stays in view while scrolling: xlsx_freeze_rows defaults to 1 where it defaulted to 0. Pass xlsx_freeze_rows => 0 for a sheet with nothing frozen. Giving xlsx_freeze_cols alone therefore freezes the header row as well as those columns. This changes the bytes of every workbook written without the option; what read_table() reads back from it is unchanged. [Tests] - Each fix above has its own new test file, 29 in all: t/alloc.guards.t, t/cor.ragged.t, t/cor_test.validation.t, t/cov.croak_leak.t, t/csort.int64.t, t/fisher_test.window.R.scipy.t, t/formula.utf8_names.t, t/group_by.tmps.t, t/lm.formula_parens.R.t, t/lmer.nested3.R.t, t/logrank_test.many_groups.R.t, t/mcnemar_test.exact.R.t, t/options.dangling_key.t, t/pbinom.huge_size.R.t, t/prcomp.small_scale.R.t, t/predict.svyglm_quasi.R.t, t/qnorm.central.R.t, t/read_table.compressed.stream.t, t/read_table.int_cells.t, t/read_table.shared_cells.t, t/sample.threshold.t, t/sets.no_upgrade.t, t/sum.overflow.R.t, t/svyglm.many_strata.t, t/tied_cell.double_fetch.t, t/wilcox_test.exact_refusal.t, t/write_table.tex.stream.t, t/xlsx.entity_scan.t and t/zerotrunc.large_counts.R.t. Expected values are frozen from R 4.6.1, from the R packages named in each header, or from the build before the change where a change is to speed alone. - Three expectations changed with the behavior they pinned: t/lm_glm_shared.t expected I(x-1) to die, t/cor.R.scipy.t expected a ragged matrix to give NaN cells, and t/read_table.colClasses.t expected an integer in a column with no class to be stored as text. - t/parse_read.t, t/read_table.colClasses.t and t/read_table.input_record_separator.t write their fixtures binary. They opened them in text mode, so on MSWin32 a quoted "line1\nline2" reached the file as "line1\r\nline2", and since 0.3418 read_table() keeps a quoted line end as the bytes the file holds. 0.3418 failed 11 subtests across the three on its two MSWin32 smokers for this, Strawberry Perl 5.24.4 and 5.42.3, the only failures among its 120 reports; the module itself was right. With PERLIO=:unix:crlf the installed 0.3418 fails the same subtests, and with this change all three pass. 0.3418 2026-11-08 CST (Claude Opus 5.5 helped) [read_table(), write_table()] - Both open a delimited file binary on every platform. On MSWin32 they opened it in text mode, so perl's :crlf layer rewrote line ends inside quoted fields as well as between rows. read_table() turned a quoted CR LF in a plain file into LF while the same file gzipped kept it, and write_table() turned a quoted LF into CR LF, so "1\r\n2" reached the file as "1\r\r\n2". 0.3417 failed three test files on a Strawberry Perl 5.42.3 smoker for this. write_table() now writes the row end itself, CR LF on Windows as before and LF elsewhere, and a field's bytes as they are, as pandas' to_csv() does. A .gz or .bz2 file is written the same way, through a plain :perlio buffer in place of the :crlf one 0.321 put there to match the text-mode plain file. [Tests] - t/crlf_quoted.tukey_aliases.regressions.t checks the bytes write_table() writes for a quoted LF and CR LF, and that read_table() reads both back. With PERLIO=:unix:crlf, which gives text-mode opens Windows' layer on Linux, the installed 0.3417 fails the same subtests the smoker did; this build passes all of them but the row-end check, which needs a perl built with PERLIO_USING_CRLF. 0.3417 2026-11-07 CST (Claude Opus 5.5 helped) [read_table()] - A line end inside a quoted field is kept as the bytes the file holds. The parser cut each line's end off before reading it and gave a line that ended inside a quote a bare "\n" back, so a CR LF in a quoted field came back as LF alone: "a\r\nb" read as "a\nb", and a value holding CR LF did not survive write_table() -> read_table(). pandas 3.0.4 keeps those bytes; R 4.6.1's read.csv() turns each CR into an LF. - The same holds in a file whose lines end in a bare CR: a quoted "x\ry" now reads as "x\ry", as pandas reads it, where it was "x\ny". [ptukey(), qtukey()] - Both accept lower and log, as pt() and the other distribution functions do, beside lower_tail and log_p. Up to 0.3416 they croaked with "unknown argument 'lower'". [Tests] - t/crlf_quoted.tukey_aliases.regressions.t pins both: five quoted strings with CR, LF and CR LF read back unchanged, as pandas reads them, a write_table() round trip, a leak check, and each alias against its long name. Against 0.3416 it fails all but the leak check and the two strings without CR LF. - The three resident-memory checks in t/audit.2026-10-20.A.t and t/audit.2026-10-20.E.t are skipped under AddressSanitizer. Its quarantine holds freed memory back from reuse, so resident memory grows with every buffer a call frees, leak or not: with libasan preloaded they grew by 280, 104 and 66 MB, and failed. [Distribution] - lib/Stats/LikeR.pm.orig, a 770 KB editing backup, is no longer in the tarball. It was tracked in git, [PruneFiles] keeps all of lib/, and so 0.3415 and 0.3416 shipped it, and `make install` copied it into site_perl beside the module. [Build] - LikeR.xs compiles clean under -Wshadow and -Wformat=2 as well: two variables in csort() and filter() no longer shadow outer ones, and the one non-literal format, the NV helper that keeps gcc from misreading quadmath's %Qg, now says so to the compiler. 0.3416 2026-11-05 CST (Claude Opus 5.5 helped) [dunn_test()] - method => 'sidak' and method => 'hs' (Holm-Sidak) no longer report an adjusted p-value of 0 for a small raw p. Both computed 1 - (1 - p)^m as written, and 1 - p rounds to 1 once p is below about 1e-16, so four well-separated groups of 200 came back with 0 for every pair where Bonferroni gives 2.96e-17; a raw p of 1e-10 kept only about six correct digits. The adjustment is now -expm1(m * log1p(-p)), the form statsmodels' multipletests() uses. [rbinom()] - size is accepted up to IV_MAX on a 32-bit perl built with 64-bit integers (i686-linux-64int). Such a perl has an 8-byte IV and a 4-byte size_t, and rbinom() held size in a size_t, so it refused size => 1e15 with "size is too large" where every other perl with 64-bit integers draws, as R does. size is now carried as a UV. This failed t/rbinom.dist.t on three CPAN smokers for 0.3414. [Tests] - t/dunn_test.statsmodels.t checks all seven of dunn_test()'s methods against statsmodels' multipletests(), with raw p-values from 0.83 down to 1.2e-148. Nothing ran sidak, hs or by before; against 0.3415 the file fails all 20 of its sidak and hs rows. - t/TukeyHSD.twoway.R.t runs TukeyHSD() on R's own two-factor example, aov(breaks ~ wool + tension, warpbreaks), with the data given as a HoA, an AoH and a HoH. Earlier tests fitted one factor and passed a HoA only. It also records a known difference from R: TukeyHSD() compares observed marginal means, while R adjusts a later factor for the earlier ones, so in an unbalanced design the two disagree for every factor after the first. Those rows run as TODO tests. - t/prop_test.R.statsmodels.t checks prop_test() with given null proportions, as an array and as a single number, against the R results recorded in statsmodels' test suite, and checks each way of raising the "Chi-squared approximation may be incorrect" warning. 0.3415 2026-11-04 CST (Claude Opus 5.5 helped) [Windows: build] - Stats::LikeR builds on Windows again. alloc_probe_ok(), which lets matrix(), runif(), rnorm(), rbinom() and add_data() croak rather than exit when the memory a count asks for is not there, called malloc() without the interpreter context. Every Windows perl defines PERL_IMPLICIT_SYS, under which XSUB.h makes malloc() and free() into PerlMem_malloc() and PerlMem_free(), and those need it: a Strawberry 5.42.3 smoker of 0.3414 stopped at "'my_perl' undeclared". That allocator returns NULL rather than aborting, so the croak is unchanged. - No Linux perl can be built with PERL_IMPLICIT_SYS, so the author's matrix script now also compiles LikeR.c with it defined against a threaded perl's headers. Against 0.3414 that reports the smoker's error and nothing else. 0.3414 2026-11-02 CST (Claude Opus 5.5 helped) [Distribution metadata] - The META homepage is https://metacpan.org/dist/Stats-LikeR. It pointed at https://metacpan.org/dist/stats, the GitHub repository's name rather than the distribution's, which is not a page on MetaCPAN. - Stats::LikeR::Usage is no longer indexed. It holds the help screens printed above a calling error, has no POD and no interface of its own, and MetaCPAN listed it beside Stats::LikeR as a module with no abstract. [Documentation] - The Synopsis is now a runnable example: read a table, summarize it, take a mean and sd, compare two groups with t_test() and fit lm(). The prose that was there moves to a new Description, which now says where these functions follow R rather than List::Util: min(), max(), sum(), mean(), median(), sd() and var() croak when called with no arguments, where List::Util returns undef, and a NaN in the input makes the result NaN. - add_data()'s resulting structures are written as Perl data rather than JSON, and the mixed-hash example now shows the target it starts from. - age_standardize() documents an example value for se, 114.4. R gives the same value for the example's data from sqrt(sum(w^2 * count / pop^2)), with w the standard population's weights, scaled by per. [rank()] - ties_method => 'random' seeds the generator before drawing, as runif() and sample() do. It called Drand01() without AUTO_SEED_PRNG(), so a process that never called srand() drew from an unseeded generator, and every run broke ties in the same order. - A tied array, a tied element and a tied scalar argument are ranked by their values. Elements were tested with SvOK() before their get magic ran, so every element of a tied array read as undef: a tied (3, 1, 2) ranked as 1 2 3, the ranks of three NAs. Each is now fetched once. - An array that grows while it is read, through a FETCH that pushes onto it, is read only as far as it was counted. The gather loop took each array's length again, so a growing array could write past the end of the work buffers. - The work buffers are on the save stack, so a croak part-way through, from an overloaded value or a FETCH that dies, no longer leaks them. They were freed by hand at the end. t/rank.tied_random.t covers all four. [lm() and glm()] - A predictor is aliased by R's rule: when what the columns before it leave of it has a norm below 1e-7 of its own (lm.fit()'s tol), or min(1e-7, epsilon/1000) for glm(), as glm.fit() has it. The test was 1e-10 on a squared pivot of X'X, which is 1e-5 on the norm, so a predictor such as x = 1e4 + noise of sd 0.05, which R fits, came back NaN from lm() and from gaussian and poisson glm() alike. vif() asks the same question and gets the same answer. - Both fit by factoring X, with AS 274 Givens rotations as anova() and aov() already did and one step of refinement on the residuals, rather than by solving the normal equations, which square the condition number. On R's longley data (kappa 2.4e7) the estimates were 2.7e-8 from R's and are now within 3e-12; across t/lm.R.scipy.t's 42 designs the worst disagreement with R fell from 1.3e-8 to 6.9e-12. - lm() is 6 to 14 times faster on a wide design: 0.36 s, against 5.1 s, for y ~ x + g on 2e5 rows with 50 levels of g, and 0.46 s against 3.0 s for 40 numeric columns. It built X'X with a column-strided walk for every pair of columns. glm()'s iterations do more work per row than X'X did, and the same poisson fit takes 0.97 s against 0.72 s. - t/lm.collinear.R.t has R's longley and PR#2776 cases, SciPy's test_regress_against_R data shifted by 1e7, and Wilkinson's NASTY regressions. [cor_test()] - continuity => 1 corrects Spearman's asymptotic t as R does, adding 1 to n(n^2 - 1)/6 before rho is formed from S, and takes the two-sided tail S lies in. It was ignored, with a warning that R ignores it too, which R does not: on R's own case, x = 1:5 against y = (8, 6, 7, 5, 3), R's two-sided p is 0.0969 and cor_test() gave the uncorrected 0.0374. t/cor_test.spearman_continuity.R.t crosses every case with both settings. [Values with get magic] - pt(), qt(), pchisq(), qchisq(), pf(), qf() and pbinom() read a capture variable or a tied scalar passed positionally: after "10" =~ /(\d+)/, pt(2.5, $1) croaked "'(undef)' was given with no value", because the argument was tested with SvOK() before its magic had run. - The same order made p_adjust() read a tied p-value in a flat list as undef, which it counts as 1; kruskal_test() drop a tied cell in either input form; friedman_test() drop a block with a tied cell; and aov() without a formula leave a tied cell out. t/tied_cell.magic_order.t covers each. [Tied cells that change the data being read] - A FETCH that frees, grows or empties the container being read no longer makes these read freed memory, which valgrind showed for each and which segfaulted or panicked several: median() of two arrays (a FETCH that grew the second wrote past the buffer; it now croaks), kruskal_test()'s x and g form (a FETCH that emptied g), hoa2aoh(), hoa2hoh(), add_data(), vals(), avals(), sample() of an array and of a hash, scale() of a matrix, and prcomp(). Each now holds the rows and columns it reads, or re-reads an array's block after every FETCH. t/tied_cell.free_mid_read.t covers each. - A FETCH that dies no longer leaks: cor()'s buffers (310 kB a call for two vectors of 20000, 145 kB for a 300 x 60 matrix), matrix()'s half- built result (20004 SVs for 2 x 10000), friedman_test()'s buffers, vals() and avals()'s copies, and sample()'s entry table for a hash. Each is on the save stack or mortal from the start. [Croaks that leaked or exited] - A formula crossing more than 16 terms with '*' croaks without leaking the term lists it had built, 0.66 kB a call, in lm(), glm() and every function that reads a formula through lm_formula_terms(). - runif(), rnorm() and rbinom() croak on an n there is no memory for, as matrix() already did, and add_data() on a numeric key that would extend an array past it. runif(1e11) took the interpreter down with "Out of memory in perl:util:safesysmalloc", which eval cannot catch. [Distribution functions] - pt(), pf(), qt() and qf() on the log scale were wrong, or NaN, in the far tail when one shape of the incomplete beta was at least 1000 and the other at most 1, as at large df. incbeta_xy_core() sent such cases to bgrat(), whose expansion is poor for a tiny variable; it now chooses the method as R's bratio() does, which for a tiny variable is TOMS 708's power series, bpser(). Up to 0.3413 pt(-3000, 5000, log => 1) was NaN, pt(-960, 2508.3, log => 1) was -7415.88159 for -7415.88469, and qt(-7500, 2500, log => 1) was -1001.09374 for -1001.09067. t/pt.log_tail.R.t pins the four functions against R 4.6.1; in 14 rows R's own qt() and qf() are off, and those take mpmath's value at 60 digits, solved by bisection. [Model frames] - lm(), glm(), anova(), aov() and the formula readers behind zerotrunc(), hurdle(), svyglm(), ivreg(), lmer(), coxph() and vif() took the data's shape and row count from whichever hash entry perl returned first, so the result depended on hash order. A row-name column that came first and was shorter or longer than the data made every data column fail the length check ("HoA columns have unequal lengths"), and a plain scalar entry such as note => 'meta' croaked "Hash values must be ArrayRefs" when it came first and was ignored otherwise. The shape is now decided from the whole hash and n from the data columns, and a scalar entry in a hash of arrays is always ignored, as assign() ignores it and as R's model.frame() ignores a variable the formula does not name. t/lm_read_rows.order.t runs each case under 24 hash seeds. [glm()] - The fitted mean is clamped as R's own family objects clamp it: pmax(exp(eta), .Machine$double.eps) for poisson and negbin, and for the logit R's logit_linkinv(), which clamps eta at +-30, with mu.eta a function of eta. The poisson and negbin mean and variance were floored at 1e-10 and the binomial mean at 10 * DBL_EPSILON, so a fit with fitted rates far below 1e-10 was off by up to 4e-10 in its coefficients (slope 1.0734182285526 where R gives 1.0734182281786); it now agrees with R to rounding. t/glm_mu_floor.R.t has the cases, and t/model_pvalue_tails.t's huge-z binomial case moves with it. - Multiway clustering numbers each intersection of the cluster variables by packing their integer labels into one key, rather than building a Perl hash per intersection, in glm() and ivreg(). The partition, its numbering and every result are bit for bit unchanged; a poisson fit on 1e6 rows with three cluster variables went from 3.25 s to 1.22 s, and with two from 1.64 s to 1.03 s. [Count models] - The digamma and trigamma behind glm(family => 'negbin')'s theta and zerotrunc() and hurdle() were good to only 2e-10 and 1.7e-8: the recurrence stopped at x = 6 and the series was cut after B_8. They now take a 12-term series from x = 7 (9 on long double, 50 on __float128) and agree with mpmath to a few ulp, and the standard error of theta agrees with R to 2.4e-13, where it was 6.7e-9 out. nb_theta_ml() also computes them once per Newton step rather than once per row. [lmer()] - The criterion no longer passes over all n rows each time the optimizer evaluates it: X'X, X'y and the least-squares residual terms are formed once per fit, so an evaluation costs only the per-block factorizations. A random-slope fit with 50 groups at n = 200,000 went from 2.5 s to 0.12 s, a random intercept from 0.51 s to 0.09 s, and two grouping factors from 1.3 s to 0.19 s. The residual sum of squares is expanded about the least-squares fit rather than from y'y, so it does not cancel when y has a large mean, and the reported fit still takes an exact residual pass; theta, sigma and the coefficients agree with the previous code to about 1e-9. - lmer()'s deviance and glm()'s gaussian AIC use pi at the NV's width rather than the double M_PI, which put a constant offset of about n * 4e-17 into both on long-double and quadmath perls. [interpolate()] - A NaN cell is a gap, as pandas treats it, for every method and every limit, limit_direction and limit_area. Only undef was, and a NaN was taken for an anchor, so [1, undef, 3, NaN, 5, undef, 7, 8, 9] interpolated with method => 'cubic' came back 1 NaN 3 NaN 5 NaN 7 8 9 where pandas gives 1 to 9, and under any method that fits the whole column one NaN made every gap NaN. A NaN in the x coordinates croaks, as pandas refuses a NaN index; it used to pass the increasing check, since every comparison with NaN is false. t/interpolate.nan.pandas.t pins about 1,700 cases against pandas 3.0.4 over the whole limit space. - limit is applied in O(n), not O(n * limit): each gap rescanned its whole window, so one 200,000-cell gap with limit_direction => 'both' took 4.1 s at limit 100000 and now takes 0.03 s. The cells filled are unchanged on 12,000 random frames. [qcut()] - NaN is missing, as it is to pandas, as well as undef: it is left out of the cutpoints and its code comes back undef. A NaN was binned as a number, and every edge it touched came back NaN. t/qcut.nan.pandas.t has pandas' test_qcut_nas and test_qcut_nullable_integer cases. [p_adjust()] - Holm's running maximum started at 0, where R's cummax() has no floor, and hommel was clamped to 1, which R's is not, so p-values outside [0, 1] came back differently from R: p_adjust([-1, 0.5, 2], 'holm') was 0 1 1 for R's -3 1 1. Values in [0, 1] are unchanged. - The p-values are sorted with an inlined sort rather than qsort() and a comparator, with the same order: 1,000,000 of them take 0.11 s, against 0.22 s. [rbinom()] - size is a trial count, bounded by what the generator can carry, IV_MAX of the running perl, rather than by the 2^48 meant for element counts: rbinom(n => 3, size => 1e15, prob => 0.3) draws, as R does, where it croaked "size is too large". On a perl with 32-bit integers a size between 2^31 and 2^32 croaks instead of running billions of Bernoulli trials. [predict()] - An interaction term was copied into a 512-byte buffer to find its factor components, so an interaction of long names lost the factor and every row came back NaN; it is scanned in place now. The unseen-level error no longer cuts the factor's name and level at 256 bytes. t/predict.long_names.t compares predict() with lm()'s fitted values for names up to 1200 bytes. [filter()] - A compiled predicate held borrowed pointers to every cell of a row while it tested them, so a tied cell whose FETCH cleared the row left the next test reading a freed scalar. A row with a tied cell now holds its cells for the test. t/tied_cell.filter_clears_row.t has the case; valgrind cannot show the old read, because perl frees scalars into its own arenas. [csort()] - A numeric column sorts about twice as fast, 0.21 s against 0.40 s for a million doubles: each cell is read once into a (value, row) pair and the pairs are sorted with an inlined comparison, ties broken by row, so the order is the one the stable merge sort gave, with undef, missing and NaN last in their original order. - Sorting an array of hashes into "hoa" or "aoa" no longer makes a mortal SV for every input cell: the key-union passes look each key up by its stored bytes and make an SV only for a new name, as merge() does. On 200,000 rows of 22 columns the peak fell from +355 MB to +170 MB ("hoa") and from +377 MB to +192 MB ("aoa"), and the call is about 30% faster. The column names are ordered with qsort() rather than an insertion sort; two names with the same bytes, one UTF-8 and one not, are now ordered by that flag rather than by hash order. [oneway_test()] - The formula form made a mortal key for every row, which lived until the call returned: a million-row call peaked 71 MB above its baseline. One key is reused, and the peak is 24 MB. [write_table()] - An .xlsx is checksummed eight bytes at a time (slicing-by-8, byte loads only), so a 100000 x 20 mixed table, 101 MB, writes in 0.5 s rather than 0.7 s, byte for byte the same file. [Portability] - LikeR.xs uses NV_NAN and NV_INF throughout in place of the C99 NAN and INFINITY, and formats row numbers with perl's UVuf rather than a C "%lu", which is 32 bits wide on Windows. 0.3413 2026-10-29 CDT (Claude Opus 5.5 helped) [Build: gcc 13 and 14 at -O3] - hist() gives finite midpoints again when built with gcc 13 or 14 at -O3, for data whose range is wider than the largest double. Two finite breaks whose sum overflows were found by testing the overflowed midpoint for Inf and then halving each break first; gcc's predictive commoning and jump threading together turned that test into an assumption that the next break was +Inf, so the following midpoint came back Inf. A Cygwin perl 5.44.0 smoker of 0.3412 (gcc 14.4.0, -O3) failed 6 subtests of t/hist.R.t this way, and gcc-13 and gcc-14 at -O3 reproduce all 6 here. The halved form is now chosen from the breaks' own magnitudes, above NV_MAX / 2, where halving is exact, so the result equals R's wherever R's is finite. - The other overflow tests of the same shape no longer give gcc anything to reason back from: median()'s halved pair, now chosen from the pair's magnitudes as hist()'s is, and the finiteness tests on to - from in seq(), on the range in pretty() and its break fill, and on a + b in the incomplete beta, each of which falls back on its operands. Those four test the difference through a volatile, as pretty()'s nu loop has since 0.3412. None of them miscompiles under gcc 13 or 14 at -O3 here, but each has the shape that did, and the next gcc need not spare them. 0.3412 2026-10-29 CDT (Claude Opus 5.5 helped) [Build: gcc 15.2.0] - hist() gives R's breaks again when built with gcc 15.2.0, for data whose range is wider than the largest double. pretty() steps its bounds back from an overflowed product with R's own `while (!finite(nu * unit)) nu--`, and gcc 15.2.0 (not 15.1 or 15.3) miscompiles that at -O2 and -O3: the loop stopped one step low, so hist([1.7e308, -1.7e308]) came back with one interval where R has two, and breaks of 0 and 0. A perl 5.44.0 smoker of 0.3411 failed 124 subtests of t/hist.R.t this way. The product now passes through a volatile, which keeps gcc from reasoning back from it to nu; the arithmetic is R's as before. The fault was reproduced with the function extracted, on Compiler Explorer's gcc 15.2. 0.3411 2026-10-28 CDT (Claude Opus 5.5 helped) [Build] - It builds on Cygwin again. 0.341 declared the warning catcher that csort() installs to find which rows its comparator reads undef from as `static XS()`, so that it would not be exported; on Cygwin, XS() is XS_EXTERNAL and carries __declspec(dllexport), which gcc refuses on a static function ("external linkage required for symbol 'cs_uninit_catcher' because of 'dllexport' attribute"). It is now declared XS_INTERNAL, perl's own static XSUB, with a fallback copied from XSUB.h for perls before 5.15.2, which do not have it and get no help from ppport.h. [Windows: three-digit exponents] - value_counts() keys a number the way perl stringifies it on Windows perls built against MSVCRT, such as Strawberry 5.24. Its fast renderer for doubles, also used by drop_duplicates() and merge(), always wrote a two-digit exponent (1e+20), while perl's %g there is the CRT's and writes three (1e+020), so such numbers were counted under keys perl would never produce. The fast path is now taken only when perl itself writes 1e20 as 1e+20, and perl's own stringification is used otherwise. - t/power_t_test.R.scipy.t takes the 1e+07 in an expected croak message from perl's own %g rather than hardcoding it, since that message is formatted by perl and reads 1e+007 on the same perls. 0.341 2026-10-26 CDT (Claude Opus 5.5 helped) [write_table: workbooks of several worksheets] - write_table(\%book, 'out.xlsx') writes a hash of data frames as one workbook, a worksheet per key, the keys sorted as a HoH's rows are. A sheet is any frame but a flat hash (AoH, AoA, HoA, HoH), or an empty [] or {}; col_names, row_names, undef_val, xlsx_comment and the freeze options apply to every sheet. It is the shape read_table returns for a workbook of several sheets, so the two round-trip. Up to 0.34 such a hash was taken for a HoA or HoH and refused: "Cannot write nested reference types to table". The sheets are streamed one after another, as the single worksheet was, so only the one being written is in memory; a single table's workbook is byte for byte what 0.34 wrote. - A hash is a workbook when any of its values is a data frame, an array or hash whose first defined element is a reference. Every other value must then be a frame or empty, and a column or scalar beside a frame is refused naming both keys. A workbook written to anything but .xlsx, or with xlsx_sheet, is refused. Errors and warnings about one sheet name it: "write_table: sheet 'AUR1': ...". A tied sheet is not looked into, so that no value of it is FETCHed twice; a hash whose sheets are all tied is still read as a HoA or HoH. - Each key is checked as a sheet name before the file is opened, and two keys the same with case ignored (Sheet1, sheet1) are refused, as Excel::Writer::XLSX 1.15 and XlsxWriter 1.3.9 refuse them; case is folded with perl's lc(), as Excel::Writer::XLSX folds it. A name starting or ending with an apostrophe, which Excel refuses, is now refused for xlsx_sheet too. t/write_table.xlsx.book.t takes its cases from pandas 3.0.4's test_creating_and_reading_multiple_sheets and test_sheets and from Excel::Writer::XLSX 1.15's workbook_check_sheetname.t. [write_table: who wrote a workbook, and with what] - An .xlsx workbook's document comments (dc:description) now record the login name, the host name, the perl version and the Stats::LikeR version, one "user:", "host:", "perl:" and "Stats::LikeR:" line each, between the "written by /