Evidence · FSL
FAST
fast divides a brain into CSF, grey matter and white matter, with the partial volume of each tissue in each voxel and a bias field, and fMRIPrep runs it on every T1w. The replica (larmorx-nc) gives FSL 6.0.7.23’s files, messages and exit status byte for byte in all 59 of its compared cases, out of 87, fMRIPrep’s own calls among them. The clean room (larmorx) is within its record’s thresholds in 64 of its 65 compared cases, out of 102, and gives FSL’s bytes in 54 of them, fMRIPrep’s three calls among them. By default both correct a class variance that loses most of its digits (FSL-202), and on fMRIPrep’s call the clean room runs 9 to 11 times as fast as FSL on one thread, 47 to 67 times on 14.
- Ports
- replica
larmorx-ncFSL Licence: non-commercial use only: translated from FSL 6.0.7.23's source (fsl-fast4 2111.3); it runs as a separate program - clean room
larmorxApache-2.0: cratelarmorx-fsl, written from specs/fast.md, the FAST paper and runs of FSL 6.0.7.23, without FSL's source (2026-11-03; brought up to the specification's answers on 2026-11-05)
- replica
- Status
- replica experimental; clean room experimental
- Records
- the replica's: standard comparison (FSL 6.0.7.23) · the clean room's: standard comparison (FSL 6.0.7.23) · benchmark fsl-fast
- Reference
fast· API page fsl-fast
What is compared
FAST models the intensities of a skull-stripped brain as a mixture of tissue classes, each a Gaussian: three by default, CSF, grey matter and white matter, in the order of their intensity on a T1w. It finds the class of every voxel by expectation-maximisation, with a hidden Markov random field that favours neighbours of the same class. It starts from a k-means of the brain’s intensities, or from given intensities (-s), or from FSL’s tissue priors registered onto the image (-a). It estimates a smooth multiplicative bias field along with the classes and divides it out at each iteration. It ends with the partial volume of each tissue in each voxel: the fraction of CSF, grey and white matter that a voxel at a boundary holds, from a second random field over the mixtures of neighbouring classes.
Its outputs are the segmentation (_seg), the partial-volume maps (_pve_0 to _pve_2) and their segmentation (_pveseg), and the mixel types. On request it also writes each class’s posterior probability (-p), its binary image (-g), the bias field (-b) and the corrected image (-B). With -S n it segments several registered images together.
fMRIPrep calls it once per subject, in its anatomical workflow (anat_fit_wf/fast), on the T1w its brain extraction made (denoised, N4-corrected and skull-stripped): fast -I 0 -N -p -g -S 1 <T1w brain>, without a bias field, as N4 corrected it before. Its partial-volume maps become the CSF, grey- and white-matter probability maps fMRIPrep writes (label-CSF_probseg and the others), from which its CompCor masks are made.
The two ports run beside FSL 6.0.7.23’s fast on the same files with the same arguments. fMRIPrep’s own outputs are the files it wrote in its run, with FSL in fMRIPrep 25.2.6’s image.
larmorx fsl fast -I 0 -N -p -g -S 1 T1w_brain.nii.gz
larmorx fsl fast -b -B -o out T1w_brain.nii.gz
larmorx fsl fast -S 2 -B -o out T2w_brain.nii.gz T1w_brain.nii.gzThe first is fMRIPrep’s call. The second also writes the bias field and the corrected image. The third segments two channels; channel 1 is the image named last.
import larmorx as lx
r = lx.fsl.fast("T1w_brain.nii.gz", bias_iterations=0, no_bias=True, probabilities=True,
segments=True)
csf, gm, wm = r.partial_volumes # lx.Image each, on the input's grid
labels = r.segmentation.data # 1 CSF, 2 grey matter, 3 white matter, 0 outside the brainThe calls above leave implementation at "auto". The API page describes every option. How to read what follows: how to read the evidence.
Its two ports
FSL comes under the FSL Licence, which allows non-commercial use only. So LARMORX has two ports of its FSL programs. The replica is translated from FSL’s source and lives in its own package, larmorx-nc (pip install larmorx-nc). The clean room is in larmorx itself. It is written without FSL’s code, from FAST’s behavioural specification (specs/fast.md), the paper (Zhang, Brady and Smith, IEEE TMI 2001) and runs of FSL’s program as a black box.
implementation="auto" | "replica" | "clean-room" chooses between them ("original" in 0.1.0rc1). On the command line, larmorx --implementation clean-room fsl fast ... does the same from the next release; in 0.1.0rc1 it is the environment variable LARMORX_IMPLEMENTATION. auto, and larmorx fsl fast, take the replica when larmorx-nc is installed, else the clean room.
The replica follows FSL 6.0.7.23. It runs none of FSL’s programs and needs no FSL installation: with -a it registers the priors with FLIRT’s replica, in the same process. Its FSL libraries are the ones the replicas of mcflirt, BET and FLIRT in larmorx-nc use too: newimage, the C library’s random numbers and maths as FSL’s build calls them, and for several channels Armadillo 14.2.1’s matrix arithmetic on OpenBLAS’s LAPACK.
The clean room has every option, message, exit status and failure case. It segments one channel or any number of them, -S 9 and more too, which the replica refuses. It registers the tissue priors with FLIRT’s clean room in the same process. By default it computes exp and log correctly rounded on every platform, and in reproduce as glibc 2.35 computes them (below). It is built for speed:
- the random field’s sweeps keep FAST’s in-place order and run as a pipeline of planes, which gives the one-thread result bit for bit at any thread count;
- FSL’s blocked sums run block by block in parallel, in their order;
- the partial volumes’ 3 + 3 × 101 likelihoods per voxel go through a batched
expwith the scalar function’s bits (speed).
The C library’s last digits (since 2026-11-04). FSL takes exp and log from glibc, the C library of Linux, whose results are now and then one unit in the last place away from the exact value rounded once. LARMORX computes them correctly rounded, the same on every platform. Until 2026-11-04 the clean room did so in fix and in reproduce, so it gave what FSL computes with correctly rounded maths (identical with correctly rounded maths) rather than FSL’s own bits. Since then its reproduce computes them exactly as glibc 2.35 does, with LARMORX’s versions of glibc’s functions (larmorx_core::math). On fMRIPrep’s three calls and on every single-channel case of its record it now gives FSL’s files bit for bit: 36 cases moved from identical with correctly rounded maths to bit-identical. Its default, fix, still computes these functions correctly rounded; until the catch-up of 2026-11-05 it gave, bit for bit, what FSL computes with correctly rounded maths. That is a deliberate correction, GLIBC-07 in the register, and FAST names it nowhere: whether a segmentation moved with such last bits cannot be told without running it twice (a decision of the project of 2026-11-04, recorded with GLIBC-07).
The clean-room catch-up (2026-11-05). The specification’s answers of 2026-11-03 (specs/fast.md §12) are now in the clean room, and every example below was run again with it.
- Its default corrects FSL-202 and FSL-203 and names them, as the replica’s default does. FSL-202: with one channel, each class’s variance in the logarithm of the intensities subtracts the square of the double-precision mean, where FAST’s single-precision square cancels most digits. FSL-203: in an image whose first voxel is NaN, the intensity extrema are taken over the values that are numbers. Its
reproducegives FSL’s results. - The record holds the default to the replica’s default. With glibc’s
exp,log,expfandlogfin the default in place of the correctly rounded ones, the two defaults give the same bits on every single-channel case of the suite. So the examples’ comparison clean room, fix − replica, fix is the correctly rounded functions’ last bits alone: no larger than FSL’s own last-bit band, but on the three channels, where it is just beyond it (976 partial-volume values against FSL’s 973). - Also from the answers:
_restorestays NaN at NaN voxels unless FAST’s rule for negative values ran; the lines FAST writes before an abort, as its C library buffers them; a class without weight in several channels (FSL’sMEAN -nanlines, a permanent case). - The record gained 13 cases of the clean room’s own (
original/: standard output at FAST’s aborts and before the images are read, the NaN voxels of_restore), every one within the thresholds or rejected by both alike.
The verdicts at a glance
The replica is a translation of FSL’s source, so the question for it is whether it gives FSL’s bytes: every file FAST writes (each image’s header and data), its standard output and error, and its exit status.
fast 6.0.7.23 (standard comparison, 87 cases of the record), by category and verdictSelect a segment to list its cases below.
The replica’s record runs 87 cases against FSL 6.0.7.23 (the record). 59 give FSL’s files byte for byte. In 27 FSL refuses the input or stops, and the replica does the same, with the same message and exit status (rejected by both). Since 2026-11-03 one of them is an image whose first voxel is NaN, where FAST stops with exit status 255 and the replica’s default segments it (FSL-203). In one FSL reads and writes past the smaller of two channels of different sizes, which the replica refuses (expected divergence: FSL-104). The cases cover:
- fMRIPrep’s call on three fMRIPrep runs (an adult, the data panel’s 3.5-year-old and its glioma patient), whose partial-volume maps are fMRIPrep’s own too;
- every option with its short and long name: the image types, two to four classes and one, the bias field’s iterations and smoothing, the random field’s weights,
--nopve, the outputs,-s; - FSL’s tissue priors (
-a,-A,-P), registered by FLIRT’s replica; - one to eight channels (
-S 2to-S 8: Armadillo’s and OpenBLAS’s arithmetic followed to 8 × 8 covariances); - 2D and 4D images, integer images, NaN, negative and very large values;
- every message, exit status and failure case of the command line.
Each case also runs the replica’s default, fix, where LARMORX corrects FSL’s deterministic defects and names them (below). Since 2026-11-03 that includes the single-channel variance (FSL-202), so the default’s outputs of every single-channel case differ from FSL’s, by the amounts the examples show.
The replica’s random-testing run, half an hour long, drew 17,497 random calls on brain-extracted phantoms and crops of a real T1w: every option, one to four channels, FSL’s priors with a drawn matrix. 16,768 agree and 725 are rejected by both alike. 4 differed, all where FLIRT cannot write the registered priors and FAST then uses priors it never allocated (FSL-101): the replica’s reproduce now stops, or runs on, as FAST does, and the three kinds are cases of the record.
The clean room is written without FSL’s source, so its record holds it to the thresholds of specs/fast.md §11 instead:
- FSL’s exit status, files and messages, the numbers in them to 4 significant digits;
- for each class, a Dice coefficient of at least 0.999, with 99.9 % of the brain’s voxels identical;
- the partial volumes within 0.001 on average and 0.02 at the 99.9th percentile;
- the bias field within 10⁻⁴.
It also shows how close the clean room comes: each case it passes is classified against FSL as built and against the same unmodified FSL with CORE-MATH’s correctly rounded exp, log, expf and logf preloaded, whose difference from FSL as built is FSL’s own last-bit band.
fast 6.0.7.23 (standard comparison, 102 cases of the record), by category and verdict- Bit-identical 54
- Within the original's own variability 9
- Expected divergence 2
- Rejected by both 35
- Open difference 2
Select a segment to list its cases below.
The clean room’s record runs 102 cases against FSL 6.0.7.23 (the record, made again on 2026-11-05). 64 are within the thresholds, 35 are rejected by both alike (the same message and exit status), and 2 are expected divergences: refused where FSL reads past the smaller of two channels (FSL-104), and both defaults correcting FSL-98’s cycle of classes, a path FSL never runs. 1 is outside the thresholds.
- Bit-identical, 54 of the 64. fMRIPrep’s three calls and every single-channel case give FSL’s values bit for bit. Until 2026-11-04, 36 of them gave what FSL computes with correctly rounded maths (identical with correctly rounded maths), their differences from FSL as built coming from glibc’s last bits alone, which
reproducenow computes as glibc does. - Within FSL’s own band, 9. Several channels: the clean room equals FSL as built but in a few partial volumes, each one fraction step of 0.01 away. These are near ties, most likely decided by the last bits of the matrix arithmetic, which the clean room computes with its own LU decomposition: only the cases with several channels show them.
- Open, 1 more.
multi/s2-optionshas 20 such partial-volume values, 3 of them in an image where FSL’s band has 1. - Outside the thresholds, 1.
multi/s5has five channels, of which the first is nearly a combination of the last two. Each class’s 5 × 5 covariance is then nearly singular, and the result is decided by the matrix arithmetic’s last bits: the clean room against itself, with one rounding changed, moves further than it lands from FSL. Following LAPACK’s operation order is the replica’s job.
opt/nan-first, an image whose first voxel is NaN (FSL-203), is rejected by both alike since the catch-up: reproduce stops as FAST does, and the default segments it, naming FSL-203.
The clean room’s first random-testing run, 25 minutes long, drew 9,005 random calls from the same realistic inputs and options as the replica’s runs, FSL’s runs going through the cache of the original’s runs. 8,823 agree. Of the 182 that differed:
- 153 came from the suite’s own image reader (FSL’s zstd outputs, a NIfTI-2 quaternion), 13 from a NaN bias field outside the brain mask and 12 from messages: all corrected, in the clean room or in the suite, and kept as four permanent cases of the record;
- 3 are explained: two noise-free channels, whose ill-conditioned covariances move with the matrix arithmetic’s last bits; and a rank-deficient covariance, where the clean room’s LU decomposition finds an exactly zero pivot and aborts, as FAST does on a singular matrix, while FSL’s rounding leaves a tiny pivot and it finishes;
- one message stayed open, and is FSL’s since the catch-up: a degenerate class whose mean FSL prints as
-nanand the clean room as 1, the images agreeing (below).
In fMRIPrep: the tissue segmentation of a T1w brain
fMRIPrep’s own call on one of its runs, given to FSL 6.0.7.23 (as built, and with correctly rounded maths), to the replica in reproduce and in fix (and at one thread), and to the clean room in reproduce and in fix on 14 threads (and on one). Choose the output above the panels: the segmentation, the three partial-volume maps fMRIPrep keeps, the posterior probabilities, the mixel types, the binary classes.
The replica’s differences from FSL are zero in every one, and since 2026-11-04 so are the clean room’s in reproduce, which computes exp and log as glibc does. Until then the clean room differed from FSL in a few values, FSL’s own last bits, and was FSL with correctly rounded maths bit for bit.
The replica’s default, fix, differs from FSL since 2026-11-03. It takes each class’s variance without FAST’s cancellation (FSL-202, a deliberate correction), which moves 54 voxels of the segmentation and 112 of the mixel types on this call (the comparison replica, fix − reproduce). Measured on seven cases, fMRIPrep’s three calls among them, the corrected variance’s segmentation and mixel types lie 0 or 1 voxel from FAST computed with its class statistics in double precision throughout, where FSL’s lie 1 to 844 voxels from it. Its own last-bit band is 0 voxels, where FSL’s reaches 3 to 807: most of FSL’s own band, the yardstick’s included, is this cancellation.
Until the catch-up the clean room’s default gave, bit for bit, what FSL computes with correctly rounded maths. Since 2026-11-05 it makes the replica’s correction too. With the C library’s functions correctly rounded, it differs from the replica’s default in 27, 37 and 10 values of the CSF, grey- and white-matter maps, by at most 0.01, and in no output further than FSL itself moves with those last bits (the comparison clean room, fix − replica, fix). Below the viewer, every file FAST writes and the tissue volumes the maps give, with fMRIPrep’s own outputs (FSL in fMRIPrep’s image).
Worked example
fMRIPrep's tissue segmentation of a T1w brain
What this shows: On fMRIPrep’s own call, the replica and the clean room both give FSL’s files, every value, and the same partial-volume maps as fMRIPrep’s own. In fix, their default, both correct FSL-202 (a class variance that loses most of its digits): the replica’s segmentation moves by 54 voxels and its mixel types by 112, and the two defaults differ only by the correctly rounded functions’ last bits, within FSL’s own band.
- Replica against FSL fast 6.0.7.23Bit-identical
- Clean room against FSL fast 6.0.7.23Bit-identical
The FAST node fMRIPrep 25.2.6 ran on an adult’s T1w (ds000005): fast -I 0 -N -p -g -S 1 <T1w brain> (no bias field: fMRIPrep corrected it with N4 before; the posterior probabilities and the binary class images written too), given to FSL 6.0.7.23 (as built, and with correctly rounded maths), to the replica (larmorx-nc) in reproduce and in fix and at one thread, and to LARMORX’s clean room in reproduce and in fix at 14 threads and at one. Choose the output above the panels: the segmentation, the three partial-volume maps fMRIPrep keeps, the probabilities, the mixel types, the binary classes. Below the viewer, every file FAST writes and the tissue volumes the maps give, with fMRIPrep’s own.
- Data
- OpenNeuro ds000005 (Tom et al., 2007), snapshot 00001, sub-01 (PDDL-1.0): the T1w brain fMRIPrep computed (skull-stripped, no face); shown inside its brain, dilated by 2 voxels (1,355 ml of brain)
- Node
- fMRIPrep 25.2.6,
work/fmriprep_25_2_wf/sub_01_wf/anat_fit_wf/fast - Command
fast -I 0 -N -p -g -S 1 sub-01_T1w_noise_corrected_corrected_xform_masked.nii.gz- Programs
- FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH) (its run served from the cache of the original’s runs, as the record ran it); larmorx-nc 0.0.1 (the replica), from LARMORX at commit
3b65d4eeb6c7; the same FSL with CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27) (served from the cache of the original’s runs); LARMORX 0.0.1 (the clean room, crate larmorx-fsl, Apache-2.0), from LARMORX at commit92098004ac10 - Grid
- 160 × 192 × 192 voxels of 1 × 1.33 × 1.33 mm; shown: 151 × 125 × 111 around the brain
Data shown
- Mixed-gambles task (OpenNeuro ds000005, version 00001), Open Data Commons Public Domain Dedication and Licence 1.0.




Bit-identical5,898,240 of 5,898,240 voxels equal
Bit-identical5,898,240 of 5,898,240 voxels equal

Axial slice 67 of 111; the crosshair at the brain's centre (no voxel of the slice with the most brain differs between FSL and the clean room) (the replica agrees with FSL everywhere). The interactive viewer needs JavaScript; the metrics below are complete without it.
Every comparison, computed in float64 over every voxel of the outputs
| Comparison (A − B), verdict and reason | Output | max |Δ| | Values that differ | RMS of Δ | max |Δ| ÷ range | 1 − NCC |
|---|---|---|---|---|---|---|
| The original against itself: the yardstick | ||||||
| FSL fast, correctly rounded maths − FSL as builtreferenceThe yardstick: FSL against itself with CORE-MATH’s correctly rounded exp, log, expf and logf preloaded into the same unmodified program, so how far FSL’s result moves when only those functions’ last bits change. FAST’s single-channel variance in the log domain cancels most digits, so such a change moves a few voxels of the smallest classes and mixel types. FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 2 | 4 of 5,898,240 (6.78e−5 %) | 0.0013 | 0.667 | 1.47e−6 |
| Partial volume: CSF | 0.38 | 316 of 5,898,240 (0.00536 %) | 0.000226 | 0.38 | 1.12e−6 | |
| Partial volume: GM | 0.67 | 352 of 5,898,240 (0.00597 %) | 0.000392 | 0.67 | 2.01e−6 | |
| Partial volume: WM | 0.67 | 42 of 5,898,240 (0.000712 %) | 0.00032 | 0.67 | 1.19e−6 | |
| Classes of the partial volumes | 1 | 6 of 5,898,240 (0.000102 %) | 0.00101 | 0.333 | 8.22e−7 | |
| Probability: CSF | 0.00112 | 704,978 of 5,898,240 (12 %) | 1.39e−5 | 0.00112 | 4.01e−9 | |
| Probability: GM | 0.000259 | 760,135 of 5,898,240 (12.9 %) | 1.06e−5 | 0.000272 | 1.11e−9 | |
| Probability: WM | 0.0011 | 601,806 of 5,898,240 (10.2 %) | 1.51e−5 | 0.00112 | 2.79e−9 | |
| Mixel type | 4 | 7 of 5,898,240 (0.000119 %) | 0.00311 | 0.8 | 5.73e−6 | |
| Binary: CSF | 1 | 3 of 5,898,240 (5.09e−5 %) | 0.000713 | 1 | 9.46e−6 | |
| Binary: GM | 1 | 2 of 5,898,240 (3.39e−5 %) | 0.000582 | 1 | 3.13e−6 | |
| Binary: WM | 1 | 3 of 5,898,240 (5.09e−5 %) | 0.000713 | 1 | 6.04e−6 | |
| The replica against the original | ||||||
| replica − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this call (the record compares its messages and exit status too). | every output | identical: 0 of 5,898,240 values differ | ||||
| replica − fMRIPrep's outputBit-identicalfMRIPrep’s own files (FSL in fMRIPrep 25.2.6’s image), the partial-volume maps and their segmentation its node keeps, hold the same values. | every output | identical: 0 of 5,898,240 values differ | ||||
| The replica against itself: thread counts, fix and reproduce | ||||||
| replica, 1 thread − 4 threadsBit-identicalThe thread count changes nothing (with -N there is no bias field, the only step the replica runs in threads). | every output | identical: 0 of 5,898,240 values differ | ||||
replica, fix − reproduceDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-03): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default squares the mean of a double-precision quotient in double precision. Measured on seven cases, fMRIPrep’s three calls among them, the default’s segmentation and mixel types lie 0 or 1 voxel from FAST computed with its class statistics in double precision throughout, where FSL’s lie 1 to 844 voxels from it, and its own last-bit band is 0 voxels where FSL’s reaches 3 to 807: most of FSL’s own band is this cancellation. reproduce gives FSL’s bytes (the row of reproduce against FSL in this table). FSL-202 FSL-96 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 54 of 5,898,240 (0.000916 %) | 0.00319 | 0.667 | 8.79e−6 |
| Partial volume: CSF | 0.75 | 721 of 5,898,240 (0.0122 %) | 0.00104 | 0.75 | 2.36e−5 | |
| Partial volume: GM | 0.89 | 1,216 of 5,898,240 (0.0206 %) | 0.00145 | 0.89 | 2.74e−5 | |
| Partial volume: WM | 0.66 | 514 of 5,898,240 (0.00871 %) | 0.00106 | 0.66 | 1.3e−5 | |
| Classes of the partial volumes | 1 | 42 of 5,898,240 (0.000712 %) | 0.00267 | 0.333 | 5.76e−6 | |
| Probability: CSF | 0.0017 | 696,512 of 5,898,240 (11.8 %) | 2.15e−5 | 0.0017 | 8.95e−9 | |
| Probability: GM | 0.00129 | 759,948 of 5,898,240 (12.9 %) | 5.67e−5 | 0.00136 | 3.85e−8 | |
| Probability: WM | 0.00201 | 602,507 of 5,898,240 (10.2 %) | 6.7e−5 | 0.00204 | 5.59e−8 | |
| Mixel type | 4 | 112 of 5,898,240 (0.0019 %) | 0.0131 | 0.8 | 0.000102 | |
| Binary: CSF | 1 | 7 of 5,898,240 (0.000119 %) | 0.00109 | 1 | 2.21e−5 | |
| Binary: GM | 1 | 52 of 5,898,240 (0.000882 %) | 0.00297 | 1 | 8.14e−5 | |
| Binary: WM | 1 | 49 of 5,898,240 (0.000831 %) | 0.00288 | 1 | 9.86e−5 | |
| The clean room against the original and the replica | ||||||
| clean room − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this call. | every output | identical: 0 of 5,898,240 values differ | ||||
clean room − FSL fast, correctly rounded mathsWithin the original's own variabilityreproduce computes exp, log, expf and logf as glibc 2.35 does, as FSL’s build, so it gives FSL’s values as built, every one (the row of reproduce against FSL in this table); against FSL with correctly rounded maths its differences are therefore FSL’s own last-bit band, value for value (the yardstick row). FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 2 | 4 of 5,898,240 (6.78e−5 %) | 0.0013 | 0.667 | 1.47e−6 |
| Partial volume: CSF | 0.38 | 316 of 5,898,240 (0.00536 %) | 0.000226 | 0.38 | 1.12e−6 | |
| Partial volume: GM | 0.67 | 352 of 5,898,240 (0.00597 %) | 0.000392 | 0.67 | 2.01e−6 | |
| Partial volume: WM | 0.67 | 42 of 5,898,240 (0.000712 %) | 0.00032 | 0.67 | 1.19e−6 | |
| Classes of the partial volumes | 1 | 6 of 5,898,240 (0.000102 %) | 0.00101 | 0.333 | 8.22e−7 | |
| Probability: CSF | 0.00112 | 704,978 of 5,898,240 (12 %) | 1.39e−5 | 0.00112 | 4.01e−9 | |
| Probability: GM | 0.000259 | 760,135 of 5,898,240 (12.9 %) | 1.06e−5 | 0.000272 | 1.11e−9 | |
| Probability: WM | 0.0011 | 601,806 of 5,898,240 (10.2 %) | 1.51e−5 | 0.00112 | 2.79e−9 | |
| Mixel type | 4 | 7 of 5,898,240 (0.000119 %) | 0.00311 | 0.8 | 5.73e−6 | |
| Binary: CSF | 1 | 3 of 5,898,240 (5.09e−5 %) | 0.000713 | 1 | 9.46e−6 | |
| Binary: GM | 1 | 2 of 5,898,240 (3.39e−5 %) | 0.000582 | 1 | 3.13e−6 | |
| Binary: WM | 1 | 3 of 5,898,240 (5.09e−5 %) | 0.000713 | 1 | 6.04e−6 | |
| clean room − fMRIPrep's outputBit-identicalThe same values, every one. | every output | identical: 0 of 5,898,240 values differ | ||||
clean room, fix − FSL fast, correctly rounded mathsDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 1 | 52 of 5,898,240 (0.000882 %) | 0.00297 | 0.333 | 7.62e−6 |
| Partial volume: CSF | 0.75 | 1,026 of 5,898,240 (0.0174 %) | 0.00106 | 0.75 | 2.48e−5 | |
| Partial volume: GM | 0.89 | 1,557 of 5,898,240 (0.0264 %) | 0.0015 | 0.89 | 2.94e−5 | |
| Partial volume: WM | 0.67 | 556 of 5,898,240 (0.00943 %) | 0.00111 | 0.67 | 1.42e−5 | |
| Classes of the partial volumes | 1 | 47 of 5,898,240 (0.000797 %) | 0.00282 | 0.333 | 6.44e−6 | |
| Probability: CSF | 0.000582 | 704,568 of 5,898,240 (11.9 %) | 1.63e−5 | 0.000582 | 5.01e−9 | |
| Probability: GM | 0.00128 | 760,269 of 5,898,240 (12.9 %) | 5.93e−5 | 0.00135 | 4.29e−8 | |
| Probability: WM | 0.00139 | 602,334 of 5,898,240 (10.2 %) | 6.37e−5 | 0.00141 | 4.86e−8 | |
| Mixel type | 4 | 117 of 5,898,240 (0.00198 %) | 0.0133 | 0.8 | 0.000106 | |
| Binary: CSF | 1 | 6 of 5,898,240 (0.000102 %) | 0.00101 | 1 | 1.89e−5 | |
| Binary: GM | 1 | 52 of 5,898,240 (0.000882 %) | 0.00297 | 1 | 8.14e−5 | |
| Binary: WM | 1 | 46 of 5,898,240 (0.00078 %) | 0.00279 | 1 | 9.26e−5 | |
| clean room, fix − replica, fixWithin the original's own variabilityThe two defaults make the same corrections; the replica’s computes exp, log, expf and logf as glibc does, the clean room’s correctly rounded (with glibc’s functions in its default the two give the same bits: glibc_default.py). Partial volume: CSF: 27 values differ (at most 0.01), FSL’s own 316 (at most 0.38); Partial volume: GM: 37 values differ (at most 0.01), FSL’s own 352 (at most 0.67); Partial volume: WM: 10 values differ (at most 0.01), FSL’s own 42 (at most 0.67); 4 more; no further, in any output, than FSL itself moves when only those functions’ last bits change (the yardstick row). findings | Classes (1 CSF, 2 GM, 3 WM) | 0 | 0 of 5,898,240 | 0 | 0 | 0 |
| Partial volume: CSF | 0.01 | 27 of 5,898,240 (0.000458 %) | 2.14e−5 | 0.01 | 1.01e−8 | |
| Partial volume: GM | 0.01 | 37 of 5,898,240 (0.000627 %) | 2.5e−5 | 0.01 | 8.23e−9 | |
| Partial volume: WM | 0.01 | 10 of 5,898,240 (0.00017 %) | 1.3e−5 | 0.01 | 1.97e−9 | |
| Classes of the partial volumes | 1 | 1 of 5,898,240 (1.7e−5 %) | 0.000412 | 0.333 | 1.37e−7 | |
| Probability: CSF | 2.35e−6 | 454,931 of 5,898,240 (7.71 %) | 2.55e−8 | 2.35e−6 | 1.34e−14 | |
| Probability: GM | 1.37e−6 | 387,128 of 5,898,240 (6.56 %) | 5.79e−8 | 1.44e−6 | 3.83e−14 | |
| Probability: WM | 2.68e−6 | 419,299 of 5,898,240 (7.11 %) | 7.2e−8 | 2.72e−6 | 6.54e−14 | |
| Mixel type | 0 | 0 of 5,898,240 | 0 | 0 | 0 | |
| Binary: CSF | 0 | 0 of 5,898,240 | 0 | 0 | 0 | |
| Binary: GM | 0 | 0 of 5,898,240 | 0 | 0 | 0 | |
| Binary: WM | 0 | 0 of 5,898,240 | 0 | 0 | 0 | |
| The clean room against itself: thread counts, fix and reproduce | ||||||
| clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the clean room’s parallel sweeps (a pipeline of planes in the serial order), blocked sums and sorts give its one-thread result bit for bit at any thread count. | every output | identical: 0 of 5,898,240 values differ | ||||
clean room, fix − reproduceDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. It also computes exp, log, expf and logf correctly rounded (GLIBC-07, not named). FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 54 of 5,898,240 (0.000916 %) | 0.00319 | 0.667 | 8.79e−6 |
| Partial volume: CSF | 0.75 | 710 of 5,898,240 (0.012 %) | 0.00104 | 0.75 | 2.36e−5 | |
| Partial volume: GM | 0.89 | 1,205 of 5,898,240 (0.0204 %) | 0.00145 | 0.89 | 2.74e−5 | |
| Partial volume: WM | 0.66 | 514 of 5,898,240 (0.00871 %) | 0.00106 | 0.66 | 1.3e−5 | |
| Classes of the partial volumes | 1 | 41 of 5,898,240 (0.000695 %) | 0.00264 | 0.333 | 5.62e−6 | |
| Probability: CSF | 0.0017 | 696,521 of 5,898,240 (11.8 %) | 2.14e−5 | 0.0017 | 8.93e−9 | |
| Probability: GM | 0.00129 | 759,965 of 5,898,240 (12.9 %) | 5.67e−5 | 0.00136 | 3.84e−8 | |
| Probability: WM | 0.00201 | 602,514 of 5,898,240 (10.2 %) | 6.69e−5 | 0.00204 | 5.58e−8 | |
| Mixel type | 4 | 112 of 5,898,240 (0.0019 %) | 0.0131 | 0.8 | 0.000102 | |
| Binary: CSF | 1 | 7 of 5,898,240 (0.000119 %) | 0.00109 | 1 | 2.21e−5 | |
| Binary: GM | 1 | 52 of 5,898,240 (0.000882 %) | 0.00297 | 1 | 8.14e−5 | |
| Binary: WM | 1 | 49 of 5,898,240 (0.000831 %) | 0.00288 | 1 | 9.86e−5 | |
Δ is A − B, computed in float64 over all 5,898,240 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file FSL writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-fast) holds it to specs/fast.md §11’s thresholds instead: FSL’s exit status, files and messages (numbers to 4 significant digits); the label images per-class Dice ≥ 0.999 with ≥ 99.9 % of the mask’s voxels identical; the partial volumes’ mean |Δ| ≤ 0.001, 99.9th percentile ≤ 0.02, totals within 0.1 %; the probabilities’ mean |Δ| ≤ 0.001; the bias field and corrected image within 1e-4 relative at the 99.9th percentile.
Every image FAST writes, both ports against the original: FSL fast 6.0.7.23
| File | Type | Voxels | replica, reproduce | replica, fix | clean room, reproduce | clean room, fix | clean room − FSL fast, correctly rounded maths | clean room, fix − FSL fast, correctly rounded maths |
|---|---|---|---|---|---|---|---|---|
sub-01_T1w_noise_corrected_corrected_xform_masked_seg.nii.gz | int32 | 160 × 192 × 192 | identical | differs | data identical | 54 values differ | 4 values differ | 52 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_pve_0.nii.gz | float32 | 160 × 192 × 192 | identical | differs | data identical | 710 values differ | 316 values differ | 1,026 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_pve_1.nii.gz | float32 | 160 × 192 × 192 | identical | differs | data identical | 1,205 values differ | 352 values differ | 1,557 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_pve_2.nii.gz | float32 | 160 × 192 × 192 | identical | differs | data identical | 514 values differ | 42 values differ | 556 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_pveseg.nii.gz | int32 | 160 × 192 × 192 | identical | differs | data identical | 41 values differ | 6 values differ | 47 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_prob_0.nii.gz | float32 | 160 × 192 × 192 | identical | differs | data identical | 696,521 values differ | 704,978 values differ | 704,568 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_prob_1.nii.gz | float32 | 160 × 192 × 192 | identical | differs | data identical | 759,965 values differ | 760,135 values differ | 760,269 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_prob_2.nii.gz | float32 | 160 × 192 × 192 | identical | differs | data identical | 602,514 values differ | 601,806 values differ | 602,334 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_mixeltype.nii.gz | int32 | 160 × 192 × 192 | identical | differs | data identical | 112 values differ | 7 values differ | 117 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_seg_0.nii.gz | int32 | 160 × 192 × 192 | identical | differs | data identical | 7 values differ | 3 values differ | 6 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_seg_1.nii.gz | int32 | 160 × 192 × 192 | identical | differs | data identical | 52 values differ | 2 values differ | 52 values differ |
sub-01_T1w_noise_corrected_corrected_xform_masked_seg_2.nii.gz | int32 | 160 × 192 × 192 | identical | differs | data identical | 49 values differ | 3 values differ | 46 values differ |
Each file decompressed and compared byte for byte with FSL’s: identical, the header (its descrip, FSL’s build string, aside) and every value; data identical, every value but not the header; differs, values that differ (see the comparisons above). For the clean room, where the values are not the same, how many of the file’s values differ: from FSL’s file, and in the last two columns from the file of FSL with correctly rounded maths (the record holds them to specs/fast.md §11’s thresholds, not to FSL’s bytes; since 2026-11-04 reproduce computes exp, log, expf and logf as glibc 2.35 does and its default correctly rounded, GLIBC-07).
The tissue volumes of the partial-volume maps, both ports against the original: FSL fast 6.0.7.23 (ml)
| Run | CSF | grey matter | white matter | against FSL's |
|---|---|---|---|---|
| FSL fast 6.0.7.23 | 304.68 | 526.79 | 523.061 | the same |
| replica, reproduce | 304.68 | 526.79 | 523.061 | the same |
| replica, fix | 304.714 | 526.796 | 523.021 | differs (at most 0.011 %) |
| fMRIPrep’s output (FSL in its image) | 304.68 | 526.79 | 523.061 | the same |
| FSL fast 6.0.7.23, correctly rounded maths | 304.673 | 526.795 | 523.063 | differs (at most 0.0023 %) |
| clean room, reproduce | 304.68 | 526.79 | 523.061 | the same |
| clean room, fix | 304.714 | 526.796 | 523.021 | differs (at most 0.011 %) |
Each partial-volume map summed over every voxel in float64, times the voxel’s volume (1.778 mm³); fMRIPrep’s own maps are the node’s outputs in the run’s working directory (FSL in fMRIPrep 25.2.6’s image). the same: the three volumes equal FSL’s to the last digit of float64; otherwise the largest relative difference of the three.
Provenance of this example
- Data: OpenNeuro ds000005 (Tom et al., 2007), snapshot 00001, sub-01, PDDL-1.0
- Inputs: T1w brain (sha256 f7ddc70a9dfa3c13…)
- Runs: figures cache entry
fsl-fast/fmriprep-ds000005-sub-01-noreconall, computed 2026-11-02T21:20:15+00:00; 1 of its 4 runs made again since, last on 2026-11-03T21:54:25+00:00, with larmorx3b65d4eeb6c7; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in itsRUN_INFO.json - Runs: figures cache entry
fsl-fast/original-fmriprep-ds000005-sub-01-noreconall, computed 2026-11-03T03:10:10+00:00; 3 of its 4 runs made again since, last on 2026-11-05T11:03:15+00:00, with larmorx92098004ac10; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); “larmorx 0.0.1 (the clean-room original, crate larmorx-fsl, Apache-2.0)”, as the cache entry records it; CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27); every command, its environment, threads and exit status are in itsRUN_INFO.json
Every number above is in fsl-fast.json, exported by python -m larmorx_validation evidence fsl-fast.
The bias field
FAST’s default, which fMRIPrep’s call turns off: the bias field estimated along with the classes, in the logarithm of the intensities (where a multiplicative field adds), from each voxel’s residual against the class means weighted by its posteriors, smoothed by a Gaussian (its extent -l, 20 mm by default), and removed at each iteration. Here it is the record’s case opt/bias-outputs, on the same T1w at half resolution. Choose the bias field or the corrected image above the panels.
The clean room’s bias field is FSL’s bit for bit in reproduce: its kernel’s normalised taps stay in double precision, as runs of FSL showed. Until the catch-up its default gave FSL’s with correctly rounded maths bit for bit. Since then it corrects FSL-202 as the replica’s default does, and the two defaults differ only by the correctly rounded functions’ last bits, within FSL’s own band.
Worked example
The bias field: FAST's default
What this shows: With the bias field estimated, the replica and the clean room both give FSL’s bias field, corrected image and classes, every value. In fix, their default, both correct FSL-202, and the two defaults differ only by the correctly rounded functions’ last bits, within FSL’s own band.
- Replica against FSL fast 6.0.7.23Bit-identical
- Clean room against FSL fast 6.0.7.23Bit-identical
The record’s case opt/bias-outputs: FAST’s default segmentation, which estimates a smooth bias field along with the classes and divides it out at each iteration (-b writes the field, -B the corrected image, -g the binary classes), on ds000005’s skull-stripped T1w at half resolution, by FSL 6.0.7.23 (as built and with correctly rounded maths), the replica and the clean room, in reproduce and in fix; choose the bias field above the panels.
- Data
- OpenNeuro ds000005 (Tom et al., 2007), snapshot 00001, sub-01 (PDDL-1.0): the record’s input derived from fMRIPrep’s run (its skull-stripped T1w, every second voxel; oracles/inputs/fsl-fast-replica/); shown inside the brain, dilated by 2 voxels
- Case
opt/bias-outputsof both records (fsl-fast-replica,fsl-fast)- Command
fast -b -B -g -o seg t1_half.nii.gz- Programs
- FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH) (its run served from the cache of the original’s runs, as the record ran it); larmorx-nc 0.0.1 (the replica), from LARMORX at commit
3b65d4eeb6c7; the same FSL with CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27) (served from the cache of the original’s runs); LARMORX 0.0.1 (the clean room, crate larmorx-fsl, Apache-2.0), from LARMORX at commit92098004ac10 - Grid
- 80 × 96 × 96 voxels of 2 × 2.67 × 2.67 mm; shown: 80 × 67 × 60 around the brain
Data shown
- Mixed-gambles task (OpenNeuro ds000005, version 00001), Open Data Commons Public Domain Dedication and Licence 1.0.




Bit-identical737,280 of 737,280 voxels equal
Bit-identical737,280 of 737,280 voxels equal

Axial slice 36 of 60; the crosshair at the brain's centre: no voxel of the slice with the most brain differs in the bias field between FSL and the clean room (the replica agrees everywhere). The interactive viewer needs JavaScript; the metrics below are complete without it.
Every comparison, computed in float64 over every voxel of the outputs
| Comparison (A − B), verdict and reason | Output | max |Δ| | Values that differ | RMS of Δ | max |Δ| ÷ range | 1 − NCC |
|---|---|---|---|---|---|---|
| The original against itself: the yardstick | ||||||
| FSL fast, correctly rounded maths − FSL as builtreferenceThe yardstick: FSL against itself with CORE-MATH’s correctly rounded exp, log, expf and logf preloaded into the same unmodified program, so how far FSL’s result moves when only those functions’ last bits change. FAST’s single-channel variance in the log domain cancels most digits, so such a change moves a few voxels of the smallest classes and mixel types. FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 1 | 4 of 737,280 (0.000543 %) | 0.00233 | 0.333 | 4.7e−6 |
| Partial volume: CSF | 0.6 | 129 of 737,280 (0.0175 %) | 0.00137 | 0.6 | 4.2e−5 | |
| Partial volume: GM | 0.6 | 215 of 737,280 (0.0292 %) | 0.00139 | 0.6 | 2.49e−5 | |
| Partial volume: WM | 0.14 | 86 of 737,280 (0.0117 %) | 0.00024 | 0.14 | 6.69e−7 | |
| Classes of the partial volumes | 1 | 4 of 737,280 (0.000543 %) | 0.00233 | 0.333 | 4.41e−6 | |
| Mixel type | 3 | 15 of 737,280 (0.00203 %) | 0.0101 | 0.6 | 5.88e−5 | |
| Binary: CSF | 1 | 1 of 737,280 (0.000136 %) | 0.00116 | 1 | 2.53e−5 | |
| Binary: GM | 1 | 4 of 737,280 (0.000543 %) | 0.00233 | 1 | 4.99e−5 | |
| Binary: WM | 1 | 3 of 737,280 (0.000407 %) | 0.00202 | 1 | 4.86e−5 | |
| Bias field | 8.71e−5 | 94,963 of 737,280 (12.9 %) | 6.35e−6 | 0.00165 | 3.22e−6 | |
| Corrected image | 0.0602 | 94,994 of 737,280 (12.9 %) | 0.00438 | 3.05e−5 | 1.46e−10 | |
| The replica against the original | ||||||
| replica − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this case (the record compares its messages and exit status too). | every output | identical: 0 of 737,280 values differ | ||||
| The replica against itself: thread counts, fix and reproduce | ||||||
| replica, 1 thread − 4 threadsBit-identicalThe thread count changes nothing: the replica uses threads only in the bias field’s smoothing, whose sums it takes in a fixed order. | every output | identical: 0 of 737,280 values differ | ||||
replica, fix − reproduceDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-03): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default squares the mean of a double-precision quotient in double precision. Measured on seven cases, fMRIPrep’s three calls among them, the default’s segmentation and mixel types lie 0 or 1 voxel from FAST computed with its class statistics in double precision throughout, where FSL’s lie 1 to 844 voxels from it, and its own last-bit band is 0 voxels where FSL’s reaches 3 to 807: most of FSL’s own band is this cancellation. reproduce gives FSL’s bytes (the row of reproduce against FSL in this table). FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 1 | 2 of 737,280 (0.000271 %) | 0.00165 | 0.333 | 2.35e−6 |
| Partial volume: CSF | 0.6 | 79 of 737,280 (0.0107 %) | 0.00116 | 0.6 | 3.04e−5 | |
| Partial volume: GM | 0.6 | 134 of 737,280 (0.0182 %) | 0.00119 | 0.6 | 1.82e−5 | |
| Partial volume: WM | 0.14 | 55 of 737,280 (0.00746 %) | 0.000231 | 0.14 | 6.2e−7 | |
| Classes of the partial volumes | 1 | 3 of 737,280 (0.000407 %) | 0.00202 | 0.333 | 3.31e−6 | |
| Mixel type | 3 | 8 of 737,280 (0.00109 %) | 0.00798 | 0.6 | 3.68e−5 | |
| Binary: CSF | 1 | 1 of 737,280 (0.000136 %) | 0.00116 | 1 | 2.53e−5 | |
| Binary: GM | 1 | 2 of 737,280 (0.000271 %) | 0.00165 | 1 | 2.49e−5 | |
| Binary: WM | 1 | 1 of 737,280 (0.000136 %) | 0.00116 | 1 | 1.62e−5 | |
| Bias field | 6.66e−5 | 94,897 of 737,280 (12.9 %) | 4.73e−6 | 0.00126 | 1.76e−6 | |
| Corrected image | 0.0421 | 94,941 of 737,280 (12.9 %) | 0.00324 | 2.13e−5 | 7.96e−11 | |
| The clean room against the original and the replica | ||||||
| clean room − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this case. | every output | identical: 0 of 737,280 values differ | ||||
clean room − FSL fast, correctly rounded mathsWithin the original's own variabilityreproduce computes exp, log, expf and logf as glibc 2.35 does, as FSL’s build, so it gives FSL’s values as built, every one (the row of reproduce against FSL in this table); against FSL with correctly rounded maths its differences are therefore FSL’s own last-bit band, value for value (the yardstick row). FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 1 | 4 of 737,280 (0.000543 %) | 0.00233 | 0.333 | 4.7e−6 |
| Partial volume: CSF | 0.6 | 129 of 737,280 (0.0175 %) | 0.00137 | 0.6 | 4.2e−5 | |
| Partial volume: GM | 0.6 | 215 of 737,280 (0.0292 %) | 0.00139 | 0.6 | 2.49e−5 | |
| Partial volume: WM | 0.14 | 86 of 737,280 (0.0117 %) | 0.00024 | 0.14 | 6.69e−7 | |
| Classes of the partial volumes | 1 | 4 of 737,280 (0.000543 %) | 0.00233 | 0.333 | 4.41e−6 | |
| Mixel type | 3 | 15 of 737,280 (0.00203 %) | 0.0101 | 0.6 | 5.88e−5 | |
| Binary: CSF | 1 | 1 of 737,280 (0.000136 %) | 0.00116 | 1 | 2.53e−5 | |
| Binary: GM | 1 | 4 of 737,280 (0.000543 %) | 0.00233 | 1 | 4.99e−5 | |
| Binary: WM | 1 | 3 of 737,280 (0.000407 %) | 0.00202 | 1 | 4.86e−5 | |
| Bias field | 8.71e−5 | 94,963 of 737,280 (12.9 %) | 6.35e−6 | 0.00166 | 3.22e−6 | |
| Corrected image | 0.0602 | 94,994 of 737,280 (12.9 %) | 0.00438 | 3.05e−5 | 1.46e−10 | |
clean room, fix − FSL fast, correctly rounded mathsDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 1 | 2 of 737,280 (0.000271 %) | 0.00165 | 0.333 | 2.35e−6 |
| Partial volume: CSF | 0.33 | 49 of 737,280 (0.00665 %) | 0.000718 | 0.33 | 1.16e−5 | |
| Partial volume: GM | 0.33 | 80 of 737,280 (0.0109 %) | 0.000721 | 0.33 | 6.7e−6 | |
| Partial volume: WM | 0.01 | 31 of 737,280 (0.0042 %) | 6.48e−5 | 0.01 | 4.89e−8 | |
| Classes of the partial volumes | 1 | 1 of 737,280 (0.000136 %) | 0.00116 | 0.333 | 1.1e−6 | |
| Mixel type | 2 | 7 of 737,280 (0.000949 %) | 0.00616 | 0.4 | 2.19e−5 | |
| Binary: CSF | 0 | 0 of 737,280 | 0 | 0 | 0 | |
| Binary: GM | 1 | 2 of 737,280 (0.000271 %) | 0.00165 | 1 | 2.49e−5 | |
| Binary: WM | 1 | 2 of 737,280 (0.000271 %) | 0.00165 | 1 | 3.24e−5 | |
| Bias field | 2.03e−5 | 94,336 of 737,280 (12.8 %) | 1.66e−6 | 0.000385 | 2.35e−7 | |
| Corrected image | 0.0181 | 94,443 of 737,280 (12.8 %) | 0.00117 | 9.14e−6 | 1.06e−11 | |
| clean room, fix − replica, fixWithin the original's own variabilityThe two defaults make the same corrections; the replica’s computes exp, log, expf and logf as glibc does, the clean room’s correctly rounded (with glibc’s functions in its default the two give the same bits: glibc_default.py). Partial volume: CSF: 7 values differ (at most 0.01), FSL’s own 129 (at most 0.6); Partial volume: GM: 9 values differ (at most 0.01), FSL’s own 215 (at most 0.6); Partial volume: WM: 2 values differ (at most 0.01), FSL’s own 86 (at most 0.14); 2 more; no further, in any output, than FSL itself moves when only those functions’ last bits change (the yardstick row). findings | Classes (1 CSF, 2 GM, 3 WM) | 0 | 0 of 737,280 | 0 | 0 | 0 |
| Partial volume: CSF | 0.01 | 7 of 737,280 (0.000949 %) | 3.08e−5 | 0.01 | 2.13e−8 | |
| Partial volume: GM | 0.01 | 9 of 737,280 (0.00122 %) | 3.49e−5 | 0.01 | 1.57e−8 | |
| Partial volume: WM | 0.01 | 2 of 737,280 (0.000271 %) | 1.65e−5 | 0.01 | 3.15e−9 | |
| Classes of the partial volumes | 0 | 0 of 737,280 | 0 | 0 | 0 | |
| Mixel type | 0 | 0 of 737,280 | 0 | 0 | 0 | |
| Binary: CSF | 0 | 0 of 737,280 | 0 | 0 | 0 | |
| Binary: GM | 0 | 0 of 737,280 | 0 | 0 | 0 | |
| Binary: WM | 0 | 0 of 737,280 | 0 | 0 | 0 | |
| Bias field | 2.38e−7 | 15,704 of 737,280 (2.13 %) | 1.73e−8 | 4.53e−6 | 2.73e−11 | |
| Corrected image | 0.000244 | 20,737 of 737,280 (2.81 %) | 1.07e−5 | 1.24e−7 | 9.18e−16 | |
| The clean room against itself: thread counts, fix and reproduce | ||||||
| clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the clean room’s parallel sweeps (a pipeline of planes in the serial order), blocked sums and sorts give its one-thread result bit for bit at any thread count. | every output | identical: 0 of 737,280 values differ | ||||
clean room, fix − reproduceDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. It also computes exp, log, expf and logf correctly rounded (GLIBC-07, not named). FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 1 | 2 of 737,280 (0.000271 %) | 0.00165 | 0.333 | 2.35e−6 |
| Partial volume: CSF | 0.6 | 80 of 737,280 (0.0109 %) | 0.00116 | 0.6 | 3.04e−5 | |
| Partial volume: GM | 0.6 | 135 of 737,280 (0.0183 %) | 0.00119 | 0.6 | 1.82e−5 | |
| Partial volume: WM | 0.14 | 55 of 737,280 (0.00746 %) | 0.000231 | 0.14 | 6.2e−7 | |
| Classes of the partial volumes | 1 | 3 of 737,280 (0.000407 %) | 0.00202 | 0.333 | 3.31e−6 | |
| Mixel type | 3 | 8 of 737,280 (0.00109 %) | 0.00798 | 0.6 | 3.68e−5 | |
| Binary: CSF | 1 | 1 of 737,280 (0.000136 %) | 0.00116 | 1 | 2.53e−5 | |
| Binary: GM | 1 | 2 of 737,280 (0.000271 %) | 0.00165 | 1 | 2.49e−5 | |
| Binary: WM | 1 | 1 of 737,280 (0.000136 %) | 0.00116 | 1 | 1.62e−5 | |
| Bias field | 6.68e−5 | 94,900 of 737,280 (12.9 %) | 4.74e−6 | 0.00127 | 1.76e−6 | |
| Corrected image | 0.0421 | 94,943 of 737,280 (12.9 %) | 0.00325 | 2.13e−5 | 7.98e−11 | |
Δ is A − B, computed in float64 over all 737,280 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file FSL writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-fast) holds it to specs/fast.md §11’s thresholds instead: FSL’s exit status, files and messages (numbers to 4 significant digits); the label images per-class Dice ≥ 0.999 with ≥ 99.9 % of the mask’s voxels identical; the partial volumes’ mean |Δ| ≤ 0.001, 99.9th percentile ≤ 0.02, totals within 0.1 %; the probabilities’ mean |Δ| ≤ 0.001; the bias field and corrected image within 1e-4 relative at the 99.9th percentile.
Every image FAST writes, both ports against the original: FSL fast 6.0.7.23
| File | Type | Voxels | replica, reproduce | replica, fix | clean room, reproduce | clean room, fix | clean room − FSL fast, correctly rounded maths | clean room, fix − FSL fast, correctly rounded maths |
|---|---|---|---|---|---|---|---|---|
seg_seg.nii.gz | int32 | 80 × 96 × 96 | identical | differs | data identical | 2 values differ | 4 values differ | 2 values differ |
seg_pve_0.nii.gz | float32 | 80 × 96 × 96 | identical | differs | data identical | 80 values differ | 129 values differ | 49 values differ |
seg_pve_1.nii.gz | float32 | 80 × 96 × 96 | identical | differs | data identical | 135 values differ | 215 values differ | 80 values differ |
seg_pve_2.nii.gz | float32 | 80 × 96 × 96 | identical | differs | data identical | 55 values differ | 86 values differ | 31 values differ |
seg_pveseg.nii.gz | int32 | 80 × 96 × 96 | identical | differs | data identical | 3 values differ | 4 values differ | 1 value differs |
seg_mixeltype.nii.gz | int32 | 80 × 96 × 96 | identical | differs | data identical | 8 values differ | 15 values differ | 7 values differ |
seg_seg_0.nii.gz | int32 | 80 × 96 × 96 | identical | differs | data identical | 1 value differs | 1 value differs | data identical |
seg_seg_1.nii.gz | int32 | 80 × 96 × 96 | identical | differs | data identical | 2 values differ | 4 values differ | 2 values differ |
seg_seg_2.nii.gz | int32 | 80 × 96 × 96 | identical | differs | data identical | 1 value differs | 3 values differ | 2 values differ |
seg_bias.nii.gz | float32 | 80 × 96 × 96 | identical | differs | data identical | 94,900 values differ | 94,963 values differ | 94,336 values differ |
seg_restore.nii.gz | float32 | 80 × 96 × 96 | identical | differs | data identical | 94,943 values differ | 94,994 values differ | 94,443 values differ |
Each file decompressed and compared byte for byte with FSL’s: identical, the header (its descrip, FSL’s build string, aside) and every value; data identical, every value but not the header; differs, values that differ (see the comparisons above). For the clean room, where the values are not the same, how many of the file’s values differ: from FSL’s file, and in the last two columns from the file of FSL with correctly rounded maths (the record holds them to specs/fast.md §11’s thresholds, not to FSL’s bytes; since 2026-11-04 reproduce computes exp, log, expf and logf as glibc 2.35 does and its default correctly rounded, GLIBC-07).
Provenance of this example
- Data: OpenNeuro ds000005 (Tom et al., 2007), snapshot 00001, sub-01, PDDL-1.0
- Inputs: t1_half.nii.gz (sha256 9457254772f7f890…)
- Runs: figures cache entry
fsl-fast/opt-bias-outputs, computed 2026-11-02T21:23:09+00:00; 1 of its 4 runs made again since, last on 2026-11-03T21:55:22+00:00, with larmorx3b65d4eeb6c7; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in itsRUN_INFO.json - Runs: figures cache entry
fsl-fast/original-opt-bias-outputs, computed 2026-11-03T03:10:59+00:00; 3 of its 4 runs made again since, last on 2026-11-05T11:03:28+00:00, with larmorx92098004ac10; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); “larmorx 0.0.1 (the clean-room original, crate larmorx-fsl, Apache-2.0)”, as the cache entry records it; CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27); every command, its environment, threads and exit status are in itsRUN_INFO.json
Every number above is in fsl-fast.json, exported by python -m larmorx_validation evidence fsl-fast.
FSL’s tissue priors (-a), and a correction by default
With -a and a standard-to-input matrix, FAST brings FSL’s tissue priors (avg152T1’s CSF, grey- and white-matter maps) onto the image with FLIRT and starts the segmentation from them. Here it is the record’s case priors/a-verbose, on MNI152NLin2009cAsym’s T1w.
The priors are stored as 8-bit integers, and FLIRT writes its resampled values in that type truncated toward zero. The replica’s default rounds them (FSL-09), so it starts from slightly different priors and its result differs from FSL’s, which its reproduce gives byte for byte. Since 2026-11-03 the default also corrects the variance (FSL-202), as on every single-channel call. The comparison replica, fix − reproduce shows what the corrections change.
The clean room registers the priors with FLIRT’s clean room in the same process. Its reproduce gives FSL’s result bit for bit (since 2026-11-04; FSL’s with correctly rounded maths before). Its default makes the same corrections, and the two defaults give the same values, every one (the comparison clean room, fix − replica, fix).
Worked example
FSL's tissue priors (-a), and a correction by default
What this shows: From FSL’s tissue priors, the replica and the clean room both give FSL’s files, every value. In fix, their default, both round the registered priors (FSL-09) and correct FSL-202, which moves 250 voxels of the segmentation, and the two defaults give the same values, every one.
- Replica against FSL fast 6.0.7.23Bit-identical
- Clean room against FSL fast 6.0.7.23Bit-identical
The record’s case priors/a-verbose: -a with a standard-to-input matrix brings FSL’s tissue priors (avg152T1’s CSF, grey and white matter) onto the image with FLIRT and starts the segmentation from them, here on MNI152NLin2009cAsym’s 2 mm T1w inside its brain mask; -v prints every step. FSL 6.0.7.23 and the replica’s reproduce give the same bytes; the replica’s default corrects FSL-09 in FLIRT’s resampling of the priors, and so starts from other priors: the difference replica, default − reproduce shows what that changes. The clean room registers the priors with FLIRT’s clean room in the same process, in fix and in reproduce the same way.
- Data
- MNI152NLin2009cAsym’s 2 mm images from TemplateFlow, inside its brain mask (the record’s derived inputs, oracles/inputs/fsl-fast-replica/); the template, MNI ICBM 152 nonlinear asymmetric 2009c, © McConnell Brain Imaging Centre, Montreal Neurological Institute (notice)
- Case
priors/a-verboseof both records (fsl-fast-replica,fsl-fast)- Command
fast -a std2mni.mat -v -o seg mni_t1.nii.gz- Programs
- FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH) (its run served from the cache of the original’s runs, as the record ran it); larmorx-nc 0.0.1 (the replica), from LARMORX at commit
3b65d4eeb6c7; the same FSL with CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27) (served from the cache of the original’s runs); LARMORX 0.0.1 (the clean room, crate larmorx-fsl, Apache-2.0), from LARMORX at commit92098004ac10 - Priors
- FAST’s 3 registered priors (
seg_{csf,gm,wm}_stdspace, written by FLIRT and left behind): the replica’sreproducewrites FSL’s bytes; its default,fix, other values (FSL-09: rounded); the clean room’s (FLIRT’s clean room in the same process):reproduceFSL’s bytes,fix480,310 values other than FSL’s (FSL-09: rounded); FSL’s priors are not shown (FSL’s data, FSL’s licence) - Grid
- 97 × 115 × 97 voxels of 2 × 2 × 2 mm; shown: 81 × 99 × 85 around the brain
Data shown
- MNI152NLin2009cAsym template (TemplateFlow, version tpl-MNI152NLin2009cAsym git 15d7c02160f79f5218d2545b4febebeecc11531d), the MNI ICBM 152 copyright notice.





Bit-identical1,082,035 of 1,082,035 voxels equal


Axial slice 42 of 85; the crosshair where the replica's default grey matter differs most from FSL's (the clean room's default makes the same correction). The interactive viewer needs JavaScript; the metrics below are complete without it.
Every comparison, computed in float64 over every voxel of the outputs
| Comparison (A − B), verdict and reason | Output | max |Δ| | Values that differ | RMS of Δ | max |Δ| ÷ range | 1 − NCC |
|---|---|---|---|---|---|---|
| The original against itself: the yardstick | ||||||
| FSL fast, correctly rounded maths − FSL as builtreferenceThe yardstick: FSL against itself with CORE-MATH’s correctly rounded exp, log, expf and logf preloaded into the same unmodified program, so how far FSL’s result moves when only those functions’ last bits change. FAST’s single-channel variance in the log domain cancels most digits, so such a change moves a few voxels of the smallest classes and mixel types. FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 0 | 0 of 1,082,035 | 0 | 0 | 0 |
| Partial volume: CSF | 0.01 | 7 of 1,082,035 (0.000647 %) | 2.54e−5 | 0.01 | 1.21e−8 | |
| Partial volume: GM | 0.01 | 10 of 1,082,035 (0.000924 %) | 3.04e−5 | 0.01 | 8.07e−9 | |
| Partial volume: WM | 0.01 | 3 of 1,082,035 (0.000277 %) | 1.67e−5 | 0.01 | 1.72e−9 | |
| Classes of the partial volumes | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Mixel type | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| The replica against the original | ||||||
| replica − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this case (the record compares its messages and exit status too). | every output | identical: 0 of 1,082,035 values differ | ||||
| The replica against itself: thread counts, fix and reproduce | ||||||
| replica, 1 thread − 4 threadsBit-identicalThe thread count changes nothing: the replica uses threads only in the bias field’s smoothing, whose sums it takes in a fixed order. | every output | identical: 0 of 1,082,035 values differ | ||||
replica, fix − reproduceDeliberate correctionFSL-09, corrected by default with a notice: FAST registers FSL’s tissue priors (8-bit integers) onto the image with FLIRT, which writes its resampled values in that integer type truncated toward zero; the replica’s default rounds them to the nearest integer, so the priors FAST starts from, and its result, differ. reproduce gives FSL’s bytes (the row of reproduce against FSL in this table). FSL-202, corrected by default with a notice (since 2026-11-03): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default squares the mean of a double-precision quotient in double precision. Measured on seven cases, fMRIPrep’s three calls among them, the default’s segmentation and mixel types lie 0 or 1 voxel from FAST computed with its class statistics in double precision throughout, where FSL’s lie 1 to 844 voxels from it, and its own last-bit band is 0 voxels where FSL’s reaches 3 to 807: most of FSL’s own band is this cancellation. reproduce gives FSL’s bytes (the row of reproduce against FSL in this table). FSL-09 FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 250 of 1,082,035 (0.0231 %) | 0.0156 | 0.667 | 0.000117 |
| Partial volume: CSF | 0.76 | 4,628 of 1,082,035 (0.428 %) | 0.00576 | 0.76 | 0.000619 | |
| Partial volume: GM | 1 | 7,710 of 1,082,035 (0.713 %) | 0.00828 | 1 | 0.000599 | |
| Partial volume: WM | 1 | 3,175 of 1,082,035 (0.293 %) | 0.00581 | 1 | 0.000209 | |
| Classes of the partial volumes | 1 | 191 of 1,082,035 (0.0177 %) | 0.0133 | 0.333 | 8.44e−5 | |
| Mixel type | 4 | 678 of 1,082,035 (0.0627 %) | 0.0726 | 0.8 | 0.00165 | |
| The clean room against the original and the replica | ||||||
| clean room − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this case. | every output | identical: 0 of 1,082,035 values differ | ||||
clean room − FSL fast, correctly rounded mathsWithin the original's own variabilityreproduce computes exp, log, expf and logf as glibc 2.35 does, as FSL’s build, so it gives FSL’s values as built, every one (the row of reproduce against FSL in this table); against FSL with correctly rounded maths its differences are therefore FSL’s own last-bit band, value for value (the yardstick row). FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 0 | 0 of 1,082,035 | 0 | 0 | 0 |
| Partial volume: CSF | 0.01 | 7 of 1,082,035 (0.000647 %) | 2.54e−5 | 0.01 | 1.21e−8 | |
| Partial volume: GM | 0.01 | 10 of 1,082,035 (0.000924 %) | 3.04e−5 | 0.01 | 8.07e−9 | |
| Partial volume: WM | 0.01 | 3 of 1,082,035 (0.000277 %) | 1.67e−5 | 0.01 | 1.72e−9 | |
| Classes of the partial volumes | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Mixel type | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
clean room, fix − FSL fast, correctly rounded mathsDeliberate correctionFSL-09, corrected by default with a notice: FAST registers FSL’s tissue priors (8-bit integers) onto the image with FLIRT, which writes its resampled values in that integer type truncated toward zero; the clean room’s default (FLIRT’s clean room, run in the same process) rounds them to the nearest integer, so the priors FAST starts from, and its result, differ. Its reproduce follows FSL (the rows above). FSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. FSL-09 FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 250 of 1,082,035 (0.0231 %) | 0.0156 | 0.667 | 0.000117 |
| Partial volume: CSF | 0.76 | 4,629 of 1,082,035 (0.428 %) | 0.00576 | 0.76 | 0.000619 | |
| Partial volume: GM | 1 | 7,712 of 1,082,035 (0.713 %) | 0.00828 | 1 | 0.000599 | |
| Partial volume: WM | 1 | 3,176 of 1,082,035 (0.294 %) | 0.00581 | 1 | 0.000209 | |
| Classes of the partial volumes | 1 | 191 of 1,082,035 (0.0177 %) | 0.0133 | 0.333 | 8.44e−5 | |
| Mixel type | 4 | 678 of 1,082,035 (0.0627 %) | 0.0726 | 0.8 | 0.00165 | |
| clean room, fix − replica, fixBit-identicalThe clean room’s default gives the replica’s default values, every one, in every image FAST writes on this case: the two make the same corrections with the same arithmetic. | every output | identical: 0 of 1,082,035 values differ | ||||
| The clean room against itself: thread counts, fix and reproduce | ||||||
| clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the clean room’s parallel sweeps (a pipeline of planes in the serial order), blocked sums and sorts give its one-thread result bit for bit at any thread count. | every output | identical: 0 of 1,082,035 values differ | ||||
clean room, fix − reproduceDeliberate correctionFSL-09, corrected by default with a notice: FAST registers FSL’s tissue priors (8-bit integers) onto the image with FLIRT, which writes its resampled values in that integer type truncated toward zero; the clean room’s default (FLIRT’s clean room, run in the same process) rounds them to the nearest integer, so the priors FAST starts from, and its result, differ. Its reproduce follows FSL (the rows above). FSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. It also computes exp, log, expf and logf correctly rounded (GLIBC-07, not named). FSL-09 FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 250 of 1,082,035 (0.0231 %) | 0.0156 | 0.667 | 0.000117 |
| Partial volume: CSF | 0.76 | 4,628 of 1,082,035 (0.428 %) | 0.00576 | 0.76 | 0.000619 | |
| Partial volume: GM | 1 | 7,710 of 1,082,035 (0.713 %) | 0.00828 | 1 | 0.000599 | |
| Partial volume: WM | 1 | 3,175 of 1,082,035 (0.293 %) | 0.00581 | 1 | 0.000209 | |
| Classes of the partial volumes | 1 | 191 of 1,082,035 (0.0177 %) | 0.0133 | 0.333 | 8.44e−5 | |
| Mixel type | 4 | 678 of 1,082,035 (0.0627 %) | 0.0726 | 0.8 | 0.00165 | |
Δ is A − B, computed in float64 over all 1,082,035 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file FSL writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-fast) holds it to specs/fast.md §11’s thresholds instead: FSL’s exit status, files and messages (numbers to 4 significant digits); the label images per-class Dice ≥ 0.999 with ≥ 99.9 % of the mask’s voxels identical; the partial volumes’ mean |Δ| ≤ 0.001, 99.9th percentile ≤ 0.02, totals within 0.1 %; the probabilities’ mean |Δ| ≤ 0.001; the bias field and corrected image within 1e-4 relative at the 99.9th percentile.
Every image FAST writes, both ports against the original: FSL fast 6.0.7.23
| File | Type | Voxels | replica, reproduce | replica, fix | clean room, reproduce | clean room, fix | clean room − FSL fast, correctly rounded maths | clean room, fix − FSL fast, correctly rounded maths |
|---|---|---|---|---|---|---|---|---|
seg_seg.nii.gz | int32 | 97 × 115 × 97 | identical | differs | identical | 250 values differ | identical | 250 values differ |
seg_pve_0.nii.gz | float32 | 97 × 115 × 97 | identical | differs | identical | 4,628 values differ | 7 values differ | 4,629 values differ |
seg_pve_1.nii.gz | float32 | 97 × 115 × 97 | identical | differs | identical | 7,710 values differ | 10 values differ | 7,712 values differ |
seg_pve_2.nii.gz | float32 | 97 × 115 × 97 | identical | differs | identical | 3,175 values differ | 3 values differ | 3,176 values differ |
seg_pveseg.nii.gz | int32 | 97 × 115 × 97 | identical | differs | identical | 191 values differ | identical | 191 values differ |
seg_mixeltype.nii.gz | int32 | 97 × 115 × 97 | identical | differs | identical | 678 values differ | identical | 678 values differ |
Each file decompressed and compared byte for byte with FSL’s: identical, the header (its descrip, FSL’s build string, aside) and every value; data identical, every value but not the header; differs, values that differ (see the comparisons above). For the clean room, where the values are not the same, how many of the file’s values differ: from FSL’s file, and in the last two columns from the file of FSL with correctly rounded maths (the record holds them to specs/fast.md §11’s thresholds, not to FSL’s bytes; since 2026-11-04 reproduce computes exp, log, expf and logf as glibc 2.35 does and its default correctly rounded, GLIBC-07).
Provenance of this example
- Data: MNI ICBM 152 nonlinear asymmetric 2009c (Fonov et al., 2009, 2011), from TemplateFlow, the MNI ICBM 152 notice (static/hero/LICENSE-MNI.txt)
- Inputs: std2mni.mat (sha256 cd6020669c1ceb8d…); mni_t1.nii.gz (sha256 371fa6ae9e5a6704…)
- Runs: figures cache entry
fsl-fast/priors-a-verbose, computed 2026-11-02T21:23:28+00:00; 1 of its 4 runs made again since, last on 2026-11-03T21:55:28+00:00, with larmorx3b65d4eeb6c7; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in itsRUN_INFO.json - Runs: figures cache entry
fsl-fast/original-priors-a-verbose, computed 2026-11-03T03:11:01+00:00; 3 of its 4 runs made again since, last on 2026-11-05T11:03:30+00:00, with larmorx92098004ac10; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); “larmorx 0.0.1 (the clean-room original, crate larmorx-fsl, Apache-2.0)”, as the cache entry records it; CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27); every command, its environment, threads and exit status are in itsRUN_INFO.json
Every number above is in fsl-fast.json, exported by python -m larmorx_validation evidence fsl-fast.
Several channels
-S 3 segments three registered images together, here MNI152NLin2009cAsym’s T1w, T2w and BOLD reference (the record’s case multi/s3): each class a Gaussian in three dimensions with its own 3 × 3 covariance, and a bias field per channel. The last image named, the T1w, is channel 1: it names the outputs and orders the classes.
The clean room computes the covariances’ determinants and inverses with its own LU decomposition, not LAPACK’s. Its reproduce equals FSL as built, and its default equals FSL with correctly rounded maths, but in a few partial volumes one fraction step away, within FSL’s own band. No correction by default changes this call (the replica’s fix − reproduce is zero), so the two defaults differ by the correctly rounded functions’ last bits alone: here just beyond FSL’s own band, 976 grey-matter values against FSL’s 973, an open comparison.
Worked example
Three channels: T1w, T2w and BOLD reference
What this shows: With three channels, the replica gives FSL’s files, every value, and no correction by default changes them. The clean room computes each class’s 3 × 3 covariance with its own arithmetic: in reproduce 4 partial-volume values lie one step of 0.01 from FSL’s, within FSL’s own band. Its default lies just beyond that band from the replica’s default (976 grey-matter values against FSL’s 973), so that comparison stays open.
- Replica against FSL fast 6.0.7.23Bit-identical
- Clean room against FSL fast 6.0.7.23Within the original's own variability
The record’s case multi/s3: -S 3 segments three registered images together (MNI152NLin2009cAsym’s 2 mm T1w, T2w and BOLD reference inside its brain mask; the last image named, the T1w, is channel 1, which names the outputs and orders the classes), each class a Gaussian in three dimensions with its 3 × 3 covariance, a bias field per channel (-b, -B); by FSL 6.0.7.23 (as built and with correctly rounded maths), the replica and the clean room, in reproduce and in fix. The matrix arithmetic need not follow LAPACK’s bits in the clean room (specs/fast.md §8.6): its own LU decomposition.
- Data
- MNI152NLin2009cAsym’s 2 mm images from TemplateFlow, inside its brain mask (the record’s derived inputs, oracles/inputs/fsl-fast-replica/); the template, MNI ICBM 152 nonlinear asymmetric 2009c, © McConnell Brain Imaging Centre, Montreal Neurological Institute (notice)
- Case
multi/s3of both records (fsl-fast-replica,fsl-fast)- Command
fast -S 3 -B -b -o seg mni_bold.nii.gz mni_t2.nii.gz mni_t1.nii.gz- Programs
- FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH) (its run served from the cache of the original’s runs, as the record ran it); larmorx-nc 0.0.1 (the replica), from LARMORX at commit
3b65d4eeb6c7; the same FSL with CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27) (served from the cache of the original’s runs); LARMORX 0.0.1 (the clean room, crate larmorx-fsl, Apache-2.0), from LARMORX at commit92098004ac10 - Grid
- 97 × 115 × 97 voxels of 2 × 2 × 2 mm; shown: 81 × 99 × 85 around the brain
Data shown
- MNI152NLin2009cAsym template (TemplateFlow, version tpl-MNI152NLin2009cAsym git 15d7c02160f79f5218d2545b4febebeecc11531d), the MNI ICBM 152 copyright notice.






Bit-identical1,082,035 of 1,082,035 voxels equal
Bit-identical1,082,035 of 1,082,035 voxels equal

Axial slice 42 of 85; the crosshair at the brain's centre: no voxel of the slice with the most brain differs in the classes between FSL and the clean room (the replica agrees everywhere). The interactive viewer needs JavaScript; the metrics below are complete without it.
Every comparison, computed in float64 over every voxel of the outputs
| Comparison (A − B), verdict and reason | Output | max |Δ| | Values that differ | RMS of Δ | max |Δ| ÷ range | 1 − NCC |
|---|---|---|---|---|---|---|
| The original against itself: the yardstick | ||||||
| FSL fast, correctly rounded maths − FSL as builtreferenceThe yardstick: FSL against itself with CORE-MATH’s correctly rounded exp, log, expf and logf preloaded into the same unmodified program, so how far FSL’s result moves when only those functions’ last bits change. FAST’s single-channel variance in the log domain cancels most digits, so such a change moves a few voxels of the smallest classes and mixel types. FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 1 | 26 of 1,082,035 (0.0024 %) | 0.0049 | 0.333 | 1.24e−5 |
| Partial volume: CSF | 0.47 | 73 of 1,082,035 (0.00675 %) | 0.000989 | 0.47 | 2.41e−5 | |
| Partial volume: GM | 1 | 973 of 1,082,035 (0.0899 %) | 0.00427 | 1 | 0.000141 | |
| Partial volume: WM | 1 | 966 of 1,082,035 (0.0893 %) | 0.00411 | 1 | 9.98e−5 | |
| Classes of the partial volumes | 1 | 50 of 1,082,035 (0.00462 %) | 0.0068 | 0.333 | 2.13e−5 | |
| Mixel type | 4 | 85 of 1,082,035 (0.00786 %) | 0.0279 | 0.8 | 0.00025 | |
| Bias field: T1w | 1.19e−7 | 2,844 of 1,082,035 (0.263 %) | 6.01e−9 | 5.16e−7 | 1.28e−13 | |
| Bias field: T2w | 1.19e−7 | 3,291 of 1,082,035 (0.304 %) | 6.43e−9 | 3.64e−7 | 8.28e−14 | |
| Bias field: BOLD reference | 1.19e−7 | 1,853 of 1,082,035 (0.171 %) | 4.76e−9 | 1.85e−7 | 5.14e−14 | |
| Corrected: T1w | 0.00195 | 3,392 of 1,082,035 (0.313 %) | 4.19e−5 | 2.12e−7 | 9.61e−17 | |
| Corrected: T2w | 0.00195 | 3,894 of 1,082,035 (0.36 %) | 3.08e−5 | 1.89e−7 | 1.05e−16 | |
| Corrected: BOLD reference | 0.000122 | 2,435 of 1,082,035 (0.225 %) | 3.66e−6 | 9.1e−8 | 4.96e−17 | |
| The replica against the original | ||||||
| replica − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this case (the record compares its messages and exit status too). | every output | identical: 0 of 1,082,035 values differ | ||||
| The replica against itself: thread counts, fix and reproduce | ||||||
| replica, 1 thread − 4 threadsBit-identicalThe thread count changes nothing: the replica uses threads only in the bias field’s smoothing, whose sums it takes in a fixed order. | every output | identical: 0 of 1,082,035 values differ | ||||
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values. | every output | identical: 0 of 1,082,035 values differ | ||||
| The clean room against the original and the replica | ||||||
| clean room − FSL fast 6.0.7.23Within the original's own variabilityIn every output the clean room differs from FSL in no more values, and by no more, than FSL itself does when only its maths functions’ last bits change (FSL with correctly rounded maths − FSL, the yardstick row): Partial volume: CSF: 1 value differs (at most 0.01), FSL’s own 73 (at most 0.47); Partial volume: GM: 2 values differ (at most 0.01), FSL’s own 973 (at most 1); Partial volume: WM: 1 value differs (at most 0.01), FSL’s own 966 (at most 1). FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 0 | 0 of 1,082,035 | 0 | 0 | 0 |
| Partial volume: CSF | 0.01 | 1 of 1,082,035 (9.24e−5 %) | 9.61e−6 | 0.01 | 2.28e−9 | |
| Partial volume: GM | 0.01 | 2 of 1,082,035 (0.000185 %) | 1.36e−5 | 0.01 | 1.43e−9 | |
| Partial volume: WM | 0.01 | 1 of 1,082,035 (9.24e−5 %) | 9.61e−6 | 0.01 | 5.47e−10 | |
| Classes of the partial volumes | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Mixel type | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Bias field: T1w | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Bias field: T2w | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Bias field: BOLD reference | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Corrected: T1w | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Corrected: T2w | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Corrected: BOLD reference | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
clean room − FSL fast, correctly rounded mathsWithin the original's own variabilityreproduce computes exp, log, expf and logf as glibc 2.35 does, as FSL’s build (since 2026-11-04), so it is held to FSL as built (the row of reproduce against FSL in this table); from FSL with correctly rounded maths it differs by no more than FSL’s own last-bit band (the yardstick row) and its own differences from FSL as built together: Classes (1 CSF, 2 GM, 3 WM): 26 values differ (at most 1), FSL’s own 26 (at most 1); Partial volume: CSF: 74 values differ (at most 0.47), FSL’s own 73 (at most 0.47); Partial volume: GM: 973 values differ (at most 1), FSL’s own 973 (at most 1); 9 more. findings | Classes (1 CSF, 2 GM, 3 WM) | 1 | 26 of 1,082,035 (0.0024 %) | 0.0049 | 0.333 | 1.24e−5 |
| Partial volume: CSF | 0.47 | 74 of 1,082,035 (0.00684 %) | 0.000989 | 0.47 | 2.41e−5 | |
| Partial volume: GM | 1 | 973 of 1,082,035 (0.0899 %) | 0.00427 | 1 | 0.000141 | |
| Partial volume: WM | 1 | 965 of 1,082,035 (0.0892 %) | 0.00411 | 1 | 9.98e−5 | |
| Classes of the partial volumes | 1 | 50 of 1,082,035 (0.00462 %) | 0.0068 | 0.333 | 2.13e−5 | |
| Mixel type | 4 | 85 of 1,082,035 (0.00786 %) | 0.0279 | 0.8 | 0.00025 | |
| Bias field: T1w | 1.19e−7 | 2,844 of 1,082,035 (0.263 %) | 6.01e−9 | 5.16e−7 | 1.28e−13 | |
| Bias field: T2w | 1.19e−7 | 3,291 of 1,082,035 (0.304 %) | 6.43e−9 | 3.64e−7 | 8.28e−14 | |
| Bias field: BOLD reference | 1.19e−7 | 1,853 of 1,082,035 (0.171 %) | 4.76e−9 | 1.85e−7 | 5.14e−14 | |
| Corrected: T1w | 0.00195 | 3,392 of 1,082,035 (0.313 %) | 4.19e−5 | 2.12e−7 | 9.61e−17 | |
| Corrected: T2w | 0.00195 | 3,894 of 1,082,035 (0.36 %) | 3.08e−5 | 1.89e−7 | 1.05e−16 | |
| Corrected: BOLD reference | 0.000122 | 2,435 of 1,082,035 (0.225 %) | 3.66e−6 | 9.1e−8 | 4.96e−17 | |
| clean room, fix − FSL fast, correctly rounded mathsWithin the original's own variabilityThe default against FSL with correctly rounded maths: Partial volume: CSF: 1 value differs (at most 0.01), FSL’s own 73 (at most 0.47); Partial volume: GM: 7 values differ (at most 0.01), FSL’s own 973 (at most 1); Partial volume: WM: 6 values differ (at most 0.01), FSL’s own 966 (at most 1); no further, in any output, than FSL as built is from it (FSL’s own last-bit band). findings | Classes (1 CSF, 2 GM, 3 WM) | 0 | 0 of 1,082,035 | 0 | 0 | 0 |
| Partial volume: CSF | 0.01 | 1 of 1,082,035 (9.24e−5 %) | 9.61e−6 | 0.01 | 2.28e−9 | |
| Partial volume: GM | 0.01 | 7 of 1,082,035 (0.000647 %) | 2.54e−5 | 0.01 | 4.99e−9 | |
| Partial volume: WM | 0.01 | 6 of 1,082,035 (0.000555 %) | 2.35e−5 | 0.01 | 3.28e−9 | |
| Classes of the partial volumes | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Mixel type | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Bias field: T1w | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Bias field: T2w | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Bias field: BOLD reference | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Corrected: T1w | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Corrected: T2w | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| Corrected: BOLD reference | 0 | 0 of 1,082,035 | 0 | 0 | 0 | |
| clean room, fix − replica, fixOpen differenceThe two defaults make the same corrections; the replica’s computes exp, log, expf and logf as glibc does, the clean room’s correctly rounded (with glibc’s functions in its default the two give the same bits: glibc_default.py). Partial volume: GM: 976 values differ (at most 1), FSL’s own 973 (at most 1); Partial volume: WM: 970 values differ (at most 1), FSL’s own 966 (at most 1); further than FSL itself moves when only those functions’ last bits change (the yardstick row). findings | Classes (1 CSF, 2 GM, 3 WM) | 1 | 26 of 1,082,035 (0.0024 %) | 0.0049 | 0.333 | 1.24e−5 |
| Partial volume: CSF | 0.47 | 72 of 1,082,035 (0.00665 %) | 0.000989 | 0.47 | 2.41e−5 | |
| Partial volume: GM | 1 | 976 of 1,082,035 (0.0902 %) | 0.00427 | 1 | 0.000141 | |
| Partial volume: WM | 1 | 970 of 1,082,035 (0.0896 %) | 0.00411 | 1 | 9.98e−5 | |
| Classes of the partial volumes | 1 | 50 of 1,082,035 (0.00462 %) | 0.0068 | 0.333 | 2.13e−5 | |
| Mixel type | 4 | 85 of 1,082,035 (0.00786 %) | 0.0279 | 0.8 | 0.00025 | |
| Bias field: T1w | 1.19e−7 | 2,844 of 1,082,035 (0.263 %) | 6.01e−9 | 5.16e−7 | 1.28e−13 | |
| Bias field: T2w | 1.19e−7 | 3,291 of 1,082,035 (0.304 %) | 6.43e−9 | 3.64e−7 | 8.28e−14 | |
| Bias field: BOLD reference | 1.19e−7 | 1,853 of 1,082,035 (0.171 %) | 4.76e−9 | 1.85e−7 | 5.14e−14 | |
| Corrected: T1w | 0.00195 | 3,392 of 1,082,035 (0.313 %) | 4.19e−5 | 2.12e−7 | 9.61e−17 | |
| Corrected: T2w | 0.00195 | 3,894 of 1,082,035 (0.36 %) | 3.08e−5 | 1.89e−7 | 1.05e−16 | |
| Corrected: BOLD reference | 0.000122 | 2,435 of 1,082,035 (0.225 %) | 3.66e−6 | 9.1e−8 | 4.96e−17 | |
| The clean room against itself: thread counts, fix and reproduce | ||||||
| clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the clean room’s parallel sweeps (a pipeline of planes in the serial order), blocked sums and sorts give its one-thread result bit for bit at any thread count. | every output | identical: 0 of 1,082,035 values differ | ||||
clean room, fix − reproduceDeliberate correctionGLIBC-07, a correction by default: the default computes exp, log, expf and logf correctly rounded on every platform, where reproduce computes them as glibc 2.35 does, as FSL’s build (LARMORX’s glibc functions, since 2026-11-04); FAST names it nowhere: an iterative fit cannot tell whether its result moved with those last bits (as decided on 2026-11-04). Classes (1 CSF, 2 GM, 3 WM): 26 values differ (at most 1), FSL’s own 26 (at most 1); Partial volume: CSF: 73 values differ (at most 0.47), FSL’s own 73 (at most 0.47); Partial volume: GM: 976 values differ (at most 1), FSL’s own 973 (at most 1); 9 more. GLIBC-07 | Classes (1 CSF, 2 GM, 3 WM) | 1 | 26 of 1,082,035 (0.0024 %) | 0.0049 | 0.333 | 1.24e−5 |
| Partial volume: CSF | 0.47 | 73 of 1,082,035 (0.00675 %) | 0.000989 | 0.47 | 2.41e−5 | |
| Partial volume: GM | 1 | 976 of 1,082,035 (0.0902 %) | 0.00427 | 1 | 0.000141 | |
| Partial volume: WM | 1 | 969 of 1,082,035 (0.0896 %) | 0.00411 | 1 | 9.98e−5 | |
| Classes of the partial volumes | 1 | 50 of 1,082,035 (0.00462 %) | 0.0068 | 0.333 | 2.13e−5 | |
| Mixel type | 4 | 85 of 1,082,035 (0.00786 %) | 0.0279 | 0.8 | 0.00025 | |
| Bias field: T1w | 1.19e−7 | 2,844 of 1,082,035 (0.263 %) | 6.01e−9 | 5.16e−7 | 1.28e−13 | |
| Bias field: T2w | 1.19e−7 | 3,291 of 1,082,035 (0.304 %) | 6.43e−9 | 3.64e−7 | 8.28e−14 | |
| Bias field: BOLD reference | 1.19e−7 | 1,853 of 1,082,035 (0.171 %) | 4.76e−9 | 1.85e−7 | 5.14e−14 | |
| Corrected: T1w | 0.00195 | 3,392 of 1,082,035 (0.313 %) | 4.19e−5 | 2.12e−7 | 9.61e−17 | |
| Corrected: T2w | 0.00195 | 3,894 of 1,082,035 (0.36 %) | 3.08e−5 | 1.89e−7 | 1.05e−16 | |
| Corrected: BOLD reference | 0.000122 | 2,435 of 1,082,035 (0.225 %) | 3.66e−6 | 9.1e−8 | 4.96e−17 | |
Δ is A − B, computed in float64 over all 1,082,035 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file FSL writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-fast) holds it to specs/fast.md §11’s thresholds instead: FSL’s exit status, files and messages (numbers to 4 significant digits); the label images per-class Dice ≥ 0.999 with ≥ 99.9 % of the mask’s voxels identical; the partial volumes’ mean |Δ| ≤ 0.001, 99.9th percentile ≤ 0.02, totals within 0.1 %; the probabilities’ mean |Δ| ≤ 0.001; the bias field and corrected image within 1e-4 relative at the 99.9th percentile.
Every image FAST writes, both ports against the original: FSL fast 6.0.7.23
| File | Type | Voxels | replica, reproduce | replica, fix | clean room, reproduce | clean room, fix | clean room − FSL fast, correctly rounded maths | clean room, fix − FSL fast, correctly rounded maths |
|---|---|---|---|---|---|---|---|---|
seg_seg.nii.gz | int32 | 97 × 115 × 97 | identical | identical | identical | 26 values differ | 26 values differ | identical |
seg_pve_0.nii.gz | float32 | 97 × 115 × 97 | identical | identical | 1 value differs | 72 values differ | 74 values differ | 1 value differs |
seg_pve_1.nii.gz | float32 | 97 × 115 × 97 | identical | identical | 2 values differ | 976 values differ | 973 values differ | 7 values differ |
seg_pve_2.nii.gz | float32 | 97 × 115 × 97 | identical | identical | 1 value differs | 970 values differ | 965 values differ | 6 values differ |
seg_pveseg.nii.gz | int32 | 97 × 115 × 97 | identical | identical | identical | 50 values differ | 50 values differ | identical |
seg_mixeltype.nii.gz | int32 | 97 × 115 × 97 | identical | identical | identical | 85 values differ | 85 values differ | identical |
seg_bias_1.nii.gz | float32 | 97 × 115 × 97 | identical | identical | identical | 2,844 values differ | 2,844 values differ | identical |
seg_bias_2.nii.gz | float32 | 97 × 115 × 97 | identical | identical | identical | 3,291 values differ | 3,291 values differ | identical |
seg_bias_3.nii.gz | float32 | 97 × 115 × 97 | identical | identical | identical | 1,853 values differ | 1,853 values differ | identical |
seg_restore_1.nii.gz | float32 | 97 × 115 × 97 | identical | identical | identical | 3,392 values differ | 3,392 values differ | identical |
seg_restore_2.nii.gz | float32 | 97 × 115 × 97 | identical | identical | identical | 3,894 values differ | 3,894 values differ | identical |
seg_restore_3.nii.gz | float32 | 97 × 115 × 97 | identical | identical | identical | 2,435 values differ | 2,435 values differ | identical |
Each file decompressed and compared byte for byte with FSL’s: identical, the header (its descrip, FSL’s build string, aside) and every value; data identical, every value but not the header; differs, values that differ (see the comparisons above). For the clean room, where the values are not the same, how many of the file’s values differ: from FSL’s file, and in the last two columns from the file of FSL with correctly rounded maths (the record holds them to specs/fast.md §11’s thresholds, not to FSL’s bytes; since 2026-11-04 reproduce computes exp, log, expf and logf as glibc 2.35 does and its default correctly rounded, GLIBC-07).
Provenance of this example
- Data: MNI ICBM 152 nonlinear asymmetric 2009c (Fonov et al., 2009, 2011), from TemplateFlow, the MNI ICBM 152 notice (static/hero/LICENSE-MNI.txt)
- Inputs: mni_bold.nii.gz (sha256 8f96f9638cf4f20a…); mni_t2.nii.gz (sha256 889933603a3d050b…); mni_t1.nii.gz (sha256 371fa6ae9e5a6704…)
- Runs: figures cache entry
fsl-fast/multi-s3, computed 2026-11-02T21:23:51+00:00; 1 of its 4 runs made again since, last on 2026-11-03T21:55:35+00:00, with larmorx3b65d4eeb6c7; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in itsRUN_INFO.json - Runs: figures cache entry
fsl-fast/original-multi-s3, computed 2026-11-03T03:11:04+00:00; 3 of its 4 runs made again since, last on 2026-11-05T11:03:33+00:00, with larmorx92098004ac10; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); “larmorx 0.0.1 (the clean-room original, crate larmorx-fsl, Apache-2.0)”, as the cache entry records it; CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27); every command, its environment, threads and exit status are in itsRUN_INFO.json
Every number above is in fsl-fast.json, exported by python -m larmorx_validation evidence fsl-fast.
On the data panel: a 3.5-year-old and a glioma patient
fMRIPrep’s call on two runs of the data panel: a 3.5-year-old’s T1w (ds000228: a small head, a child’s contrast between grey and white matter) and a glioma patient’s (ds005003: a 70 mL oligodendroglioma inside the brain mask; the slices go through it). As data-panel cases beside the first example, they are stored as three full-resolution slices, and the crosshair moves through them.
On both, the clean room’s reproduce gives FSL’s files bit for bit, as on ds000005 above, and its default corrects FSL-202 as the replica’s does, the two defaults differing only by the correctly rounded functions’ last bits. The replica’s default differs from FSL on both by FSL-202’s correction of the variance (above): 66 voxels of the segmentation and 89 of the mixel types for the child, 392 and 453 for the glioma patient.
Worked example
Data panel: a 3.5-year-old's T1w
What this shows: On the data panel’s 3.5-year-old, the replica and the clean room both give FSL’s files, every value, and the same partial-volume maps as fMRIPrep’s own. In fix, their default, both correct FSL-202 (a class variance that loses most of its digits): the replica’s segmentation moves by 66 voxels and its mixel types by 89, and the two defaults differ only by the correctly rounded functions’ last bits, within FSL’s own band.
- Replica against FSL fast 6.0.7.23Bit-identical
- Clean room against FSL fast 6.0.7.23Bit-identical
The FAST node fMRIPrep 25.2.6 ran on a 3.5-year-old’s T1w (ds000228): fast -I 0 -N -p -g -S 1 <T1w brain> (no bias field: fMRIPrep corrected it with N4 before; the posterior probabilities and the binary class images written too), given to FSL 6.0.7.23 (as built, and with correctly rounded maths), to the replica (larmorx-nc) in reproduce and in fix and at one thread, and to LARMORX’s clean room in reproduce and in fix at 14 threads and at one. Choose the output above the panels: the segmentation, the three partial-volume maps fMRIPrep keeps, the probabilities, the mixel types, the binary classes. Below the viewer, every file FAST writes and the tissue volumes the maps give, with fMRIPrep’s own. As a data-panel case beside the first example, it is stored as three full-resolution slices.
- Data
- OpenNeuro ds000228, sub-pixar008 (CC0-1.0): the T1w brain fMRIPrep computed (skull-stripped, no face); shown inside its brain, dilated by 2 voxels (1,229 ml of brain)
- Node
- fMRIPrep 25.2.6,
work/fmriprep_25_2_wf/sub_pixar008_wf/anat_fit_wf/fast - Command
fast -I 0 -N -p -g -S 1 sub-pixar008_T1w_noise_corrected_corrected_xform_masked.nii.gz- Programs
- FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH) (its run served from the cache of the original’s runs, as the record ran it); larmorx-nc 0.0.1 (the replica), from LARMORX at commit
3b65d4eeb6c7; the same FSL with CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27) (run through the cache of the original’s runs); LARMORX 0.0.1 (the clean room, crate larmorx-fsl, Apache-2.0), from LARMORX at commit92098004ac10 - Grid
- 176 × 192 × 192 voxels of 1 × 1 × 1 mm; shown: 140 × 166 × 124 around the brain
Data shown
- Children and adults watching a short film (OpenNeuro ds000228, version 1.1.1, doi:10.18112/openneuro.ds000228.v1.1.1), CC0 1.0 public-domain dedication.




Bit-identical6,488,064 of 6,488,064 voxels equal
Bit-identical6,488,064 of 6,488,064 voxels equal

Axial slice 62 of 124; the three slices through the brain's centre are stored at full resolution (the replica agrees with FSL everywhere; the clean room's differences are sought in them). The interactive viewer needs JavaScript; the metrics below are complete without it.
Stored for this example: three full-resolution slices, one per plane, through display voxel (71, 78, 62): where the main comparison differs most, or the field's centre where nothing differs; every metric is computed over every voxel of the files.
Every comparison, computed in float64 over every voxel of the outputs
| Comparison (A − B), verdict and reason | Output | max |Δ| | Values that differ | RMS of Δ | max |Δ| ÷ range | 1 − NCC |
|---|---|---|---|---|---|---|
| The original against itself: the yardstick | ||||||
| FSL fast, correctly rounded maths − FSL as builtreferenceThe yardstick: FSL against itself with CORE-MATH’s correctly rounded exp, log, expf and logf preloaded into the same unmodified program, so how far FSL’s result moves when only those functions’ last bits change. FAST’s single-channel variance in the log domain cancels most digits, so such a change moves a few voxels of the smallest classes and mixel types. FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 2 | 122 of 6,488,064 (0.00188 %) | 0.00444 | 0.667 | 1.25e−5 |
| Partial volume: CSF | 0.73 | 191 of 6,488,064 (0.00294 %) | 0.000602 | 0.73 | 1.02e−5 | |
| Partial volume: GM | 0.73 | 1,266 of 6,488,064 (0.0195 %) | 0.00119 | 0.73 | 8.01e−6 | |
| Partial volume: WM | 0.59 | 1,091 of 6,488,064 (0.0168 %) | 0.00103 | 0.59 | 1.14e−5 | |
| Classes of the partial volumes | 1 | 28 of 6,488,064 (0.000432 %) | 0.00208 | 0.333 | 2.69e−6 | |
| Probability: CSF | 0.00255 | 1,110,352 of 6,488,064 (17.1 %) | 3.16e−5 | 0.00255 | 1.79e−8 | |
| Probability: GM | 0.00222 | 1,179,713 of 6,488,064 (18.2 %) | 0.000114 | 0.00225 | 7.06e−8 | |
| Probability: WM | 0.00255 | 1,161,509 of 6,488,064 (17.9 %) | 0.00012 | 0.00257 | 1.41e−7 | |
| Mixel type | 4 | 113 of 6,488,064 (0.00174 %) | 0.0144 | 0.8 | 9.77e−5 | |
| Binary: CSF | 1 | 20 of 6,488,064 (0.000308 %) | 0.00176 | 1 | 5.5e−5 | |
| Binary: GM | 1 | 120 of 6,488,064 (0.00185 %) | 0.0043 | 1 | 9.89e−5 | |
| Binary: WM | 1 | 104 of 6,488,064 (0.0016 %) | 0.004 | 1 | 0.000151 | |
| The replica against the original | ||||||
| replica − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this call (the record compares its messages and exit status too). | every output | identical: 0 of 6,488,064 values differ | ||||
| replica − fMRIPrep's outputBit-identicalfMRIPrep’s own files (FSL in fMRIPrep 25.2.6’s image), the partial-volume maps and their segmentation its node keeps, hold the same values. | every output | identical: 0 of 6,488,064 values differ | ||||
| The replica against itself: thread counts, fix and reproduce | ||||||
| replica, 1 thread − 4 threadsBit-identicalThe thread count changes nothing (with -N there is no bias field, the only step the replica runs in threads). | every output | identical: 0 of 6,488,064 values differ | ||||
replica, fix − reproduceDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-03): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default squares the mean of a double-precision quotient in double precision. Measured on seven cases, fMRIPrep’s three calls among them, the default’s segmentation and mixel types lie 0 or 1 voxel from FAST computed with its class statistics in double precision throughout, where FSL’s lie 1 to 844 voxels from it, and its own last-bit band is 0 voxels where FSL’s reaches 3 to 807: most of FSL’s own band is this cancellation. reproduce gives FSL’s bytes (the row of reproduce against FSL in this table). FSL-202 FSL-96 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 66 of 6,488,064 (0.00102 %) | 0.00326 | 0.667 | 6.76e−6 |
| Partial volume: CSF | 0.73 | 121 of 6,488,064 (0.00186 %) | 0.000708 | 0.73 | 1.4e−5 | |
| Partial volume: GM | 0.73 | 648 of 6,488,064 (0.00999 %) | 0.00108 | 0.73 | 6.62e−6 | |
| Partial volume: WM | 0.51 | 537 of 6,488,064 (0.00828 %) | 0.000818 | 0.51 | 7.24e−6 | |
| Classes of the partial volumes | 1 | 14 of 6,488,064 (0.000216 %) | 0.00147 | 0.333 | 1.35e−6 | |
| Probability: CSF | 0.00142 | 1,108,428 of 6,488,064 (17.1 %) | 1.99e−5 | 0.00142 | 7.02e−9 | |
| Probability: GM | 0.00118 | 1,177,162 of 6,488,064 (18.1 %) | 6.14e−5 | 0.00119 | 2.04e−8 | |
| Probability: WM | 0.00142 | 1,161,097 of 6,488,064 (17.9 %) | 6.41e−5 | 0.00143 | 4.05e−8 | |
| Mixel type | 4 | 89 of 6,488,064 (0.00137 %) | 0.0121 | 0.8 | 6.96e−5 | |
| Binary: CSF | 1 | 13 of 6,488,064 (0.0002 %) | 0.00142 | 1 | 3.58e−5 | |
| Binary: GM | 1 | 65 of 6,488,064 (0.001 %) | 0.00317 | 1 | 5.36e−5 | |
| Binary: WM | 1 | 54 of 6,488,064 (0.000832 %) | 0.00288 | 1 | 7.85e−5 | |
| The clean room against the original and the replica | ||||||
| clean room − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this call. | every output | identical: 0 of 6,488,064 values differ | ||||
clean room − FSL fast, correctly rounded mathsWithin the original's own variabilityreproduce computes exp, log, expf and logf as glibc 2.35 does, as FSL’s build, so it gives FSL’s values as built, every one (the row of reproduce against FSL in this table); against FSL with correctly rounded maths its differences are therefore FSL’s own last-bit band, value for value (the yardstick row). FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 2 | 122 of 6,488,064 (0.00188 %) | 0.00444 | 0.667 | 1.25e−5 |
| Partial volume: CSF | 0.73 | 191 of 6,488,064 (0.00294 %) | 0.000602 | 0.73 | 1.02e−5 | |
| Partial volume: GM | 0.73 | 1,266 of 6,488,064 (0.0195 %) | 0.00119 | 0.73 | 8.01e−6 | |
| Partial volume: WM | 0.59 | 1,091 of 6,488,064 (0.0168 %) | 0.00103 | 0.59 | 1.14e−5 | |
| Classes of the partial volumes | 1 | 28 of 6,488,064 (0.000432 %) | 0.00208 | 0.333 | 2.69e−6 | |
| Probability: CSF | 0.00255 | 1,110,352 of 6,488,064 (17.1 %) | 3.16e−5 | 0.00255 | 1.79e−8 | |
| Probability: GM | 0.00222 | 1,179,713 of 6,488,064 (18.2 %) | 0.000114 | 0.00225 | 7.06e−8 | |
| Probability: WM | 0.00255 | 1,161,509 of 6,488,064 (17.9 %) | 0.00012 | 0.00257 | 1.41e−7 | |
| Mixel type | 4 | 113 of 6,488,064 (0.00174 %) | 0.0144 | 0.8 | 9.77e−5 | |
| Binary: CSF | 1 | 20 of 6,488,064 (0.000308 %) | 0.00176 | 1 | 5.5e−5 | |
| Binary: GM | 1 | 120 of 6,488,064 (0.00185 %) | 0.0043 | 1 | 9.89e−5 | |
| Binary: WM | 1 | 104 of 6,488,064 (0.0016 %) | 0.004 | 1 | 0.000151 | |
| clean room − fMRIPrep's outputBit-identicalThe same values, every one. | every output | identical: 0 of 6,488,064 values differ | ||||
clean room, fix − FSL fast, correctly rounded mathsDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 56 of 6,488,064 (0.000863 %) | 0.00302 | 0.667 | 5.78e−6 |
| Partial volume: CSF | 0.4 | 114 of 6,488,064 (0.00176 %) | 0.000375 | 0.4 | 3.94e−6 | |
| Partial volume: GM | 0.59 | 663 of 6,488,064 (0.0102 %) | 0.000724 | 0.59 | 2.96e−6 | |
| Partial volume: WM | 0.59 | 555 of 6,488,064 (0.00855 %) | 0.000619 | 0.59 | 4.14e−6 | |
| Classes of the partial volumes | 1 | 14 of 6,488,064 (0.000216 %) | 0.00147 | 0.333 | 1.35e−6 | |
| Probability: CSF | 0.00113 | 1,107,657 of 6,488,064 (17.1 %) | 1.21e−5 | 0.00113 | 2.64e−9 | |
| Probability: GM | 0.00104 | 1,179,222 of 6,488,064 (18.2 %) | 5.24e−5 | 0.00105 | 1.52e−8 | |
| Probability: WM | 0.00113 | 1,160,848 of 6,488,064 (17.9 %) | 5.58e−5 | 0.00114 | 3.04e−8 | |
| Mixel type | 4 | 46 of 6,488,064 (0.000709 %) | 0.00915 | 0.8 | 3.96e−5 | |
| Binary: CSF | 1 | 7 of 6,488,064 (0.000108 %) | 0.00104 | 1 | 1.93e−5 | |
| Binary: GM | 1 | 55 of 6,488,064 (0.000848 %) | 0.00291 | 1 | 4.53e−5 | |
| Binary: WM | 1 | 50 of 6,488,064 (0.000771 %) | 0.00278 | 1 | 7.27e−5 | |
| clean room, fix − replica, fixWithin the original's own variabilityThe two defaults make the same corrections; the replica’s computes exp, log, expf and logf as glibc does, the clean room’s correctly rounded (with glibc’s functions in its default the two give the same bits: glibc_default.py). Partial volume: GM: 3 values differ (at most 0.01), FSL’s own 1,266 (at most 0.73); Partial volume: WM: 3 values differ (at most 0.01), FSL’s own 1,091 (at most 0.59); Probability: CSF: 626,325 values differ (at most 3.58e-07), FSL’s own 1,110,352 (at most 0.00255); 2 more; no further, in any output, than FSL itself moves when only those functions’ last bits change (the yardstick row). findings | Classes (1 CSF, 2 GM, 3 WM) | 0 | 0 of 6,488,064 | 0 | 0 | 0 |
| Partial volume: CSF | 0 | 0 of 6,488,064 | 0 | 0 | 0 | |
| Partial volume: GM | 0.01 | 3 of 6,488,064 (4.62e−5 %) | 6.8e−6 | 0.01 | 2.62e−10 | |
| Partial volume: WM | 0.01 | 3 of 6,488,064 (4.62e−5 %) | 6.8e−6 | 0.01 | 5e−10 | |
| Classes of the partial volumes | 0 | 0 of 6,488,064 | 0 | 0 | 0 | |
| Probability: CSF | 3.58e−7 | 626,325 of 6,488,064 (9.65 %) | 1.24e−8 | 3.58e−7 | 2.65e−15 | |
| Probability: GM | 3.87e−7 | 654,900 of 6,488,064 (10.1 %) | 2.13e−8 | 3.93e−7 | 2.47e−15 | |
| Probability: WM | 3.58e−7 | 862,441 of 6,488,064 (13.3 %) | 1.69e−8 | 3.62e−7 | 2.72e−15 | |
| Mixel type | 0 | 0 of 6,488,064 | 0 | 0 | 0 | |
| Binary: CSF | 0 | 0 of 6,488,064 | 0 | 0 | 0 | |
| Binary: GM | 0 | 0 of 6,488,064 | 0 | 0 | 0 | |
| Binary: WM | 0 | 0 of 6,488,064 | 0 | 0 | 0 | |
| The clean room against itself: thread counts, fix and reproduce | ||||||
| clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the clean room’s parallel sweeps (a pipeline of planes in the serial order), blocked sums and sorts give its one-thread result bit for bit at any thread count. | every output | identical: 0 of 6,488,064 values differ | ||||
clean room, fix − reproduceDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. It also computes exp, log, expf and logf correctly rounded (GLIBC-07, not named). FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 66 of 6,488,064 (0.00102 %) | 0.00326 | 0.667 | 6.76e−6 |
| Partial volume: CSF | 0.73 | 121 of 6,488,064 (0.00186 %) | 0.000708 | 0.73 | 1.4e−5 | |
| Partial volume: GM | 0.73 | 647 of 6,488,064 (0.00997 %) | 0.00108 | 0.73 | 6.62e−6 | |
| Partial volume: WM | 0.51 | 536 of 6,488,064 (0.00826 %) | 0.000818 | 0.51 | 7.24e−6 | |
| Classes of the partial volumes | 1 | 14 of 6,488,064 (0.000216 %) | 0.00147 | 0.333 | 1.35e−6 | |
| Probability: CSF | 0.00142 | 1,108,427 of 6,488,064 (17.1 %) | 1.99e−5 | 0.00142 | 7.02e−9 | |
| Probability: GM | 0.00118 | 1,177,149 of 6,488,064 (18.1 %) | 6.15e−5 | 0.00119 | 2.04e−8 | |
| Probability: WM | 0.00142 | 1,161,092 of 6,488,064 (17.9 %) | 6.41e−5 | 0.00143 | 4.05e−8 | |
| Mixel type | 4 | 89 of 6,488,064 (0.00137 %) | 0.0121 | 0.8 | 6.96e−5 | |
| Binary: CSF | 1 | 13 of 6,488,064 (0.0002 %) | 0.00142 | 1 | 3.58e−5 | |
| Binary: GM | 1 | 65 of 6,488,064 (0.001 %) | 0.00317 | 1 | 5.36e−5 | |
| Binary: WM | 1 | 54 of 6,488,064 (0.000832 %) | 0.00288 | 1 | 7.85e−5 | |
Δ is A − B, computed in float64 over all 6,488,064 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file FSL writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-fast) holds it to specs/fast.md §11’s thresholds instead: FSL’s exit status, files and messages (numbers to 4 significant digits); the label images per-class Dice ≥ 0.999 with ≥ 99.9 % of the mask’s voxels identical; the partial volumes’ mean |Δ| ≤ 0.001, 99.9th percentile ≤ 0.02, totals within 0.1 %; the probabilities’ mean |Δ| ≤ 0.001; the bias field and corrected image within 1e-4 relative at the 99.9th percentile.
Every image FAST writes, both ports against the original: FSL fast 6.0.7.23
| File | Type | Voxels | replica, reproduce | replica, fix | clean room, reproduce | clean room, fix | clean room − FSL fast, correctly rounded maths | clean room, fix − FSL fast, correctly rounded maths |
|---|---|---|---|---|---|---|---|---|
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_seg.nii.gz | int32 | 176 × 192 × 192 | identical | differs | identical | 66 values differ | 122 values differ | 56 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_pve_0.nii.gz | float32 | 176 × 192 × 192 | identical | differs | identical | 121 values differ | 191 values differ | 114 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_pve_1.nii.gz | float32 | 176 × 192 × 192 | identical | differs | identical | 647 values differ | 1,266 values differ | 663 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_pve_2.nii.gz | float32 | 176 × 192 × 192 | identical | differs | identical | 536 values differ | 1,091 values differ | 555 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_pveseg.nii.gz | int32 | 176 × 192 × 192 | identical | differs | identical | 14 values differ | 28 values differ | 14 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_prob_0.nii.gz | float32 | 176 × 192 × 192 | identical | differs | identical | 1,108,427 values differ | 1,110,352 values differ | 1,107,657 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_prob_1.nii.gz | float32 | 176 × 192 × 192 | identical | differs | identical | 1,177,149 values differ | 1,179,713 values differ | 1,179,222 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_prob_2.nii.gz | float32 | 176 × 192 × 192 | identical | differs | identical | 1,161,092 values differ | 1,161,509 values differ | 1,160,848 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_mixeltype.nii.gz | int32 | 176 × 192 × 192 | identical | differs | identical | 89 values differ | 113 values differ | 46 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_seg_0.nii.gz | int32 | 176 × 192 × 192 | identical | differs | identical | 13 values differ | 20 values differ | 7 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_seg_1.nii.gz | int32 | 176 × 192 × 192 | identical | differs | identical | 65 values differ | 120 values differ | 55 values differ |
sub-pixar008_T1w_noise_corrected_corrected_xform_masked_seg_2.nii.gz | int32 | 176 × 192 × 192 | identical | differs | identical | 54 values differ | 104 values differ | 50 values differ |
Each file decompressed and compared byte for byte with FSL’s: identical, the header (its descrip, FSL’s build string, aside) and every value; data identical, every value but not the header; differs, values that differ (see the comparisons above). For the clean room, where the values are not the same, how many of the file’s values differ: from FSL’s file, and in the last two columns from the file of FSL with correctly rounded maths (the record holds them to specs/fast.md §11’s thresholds, not to FSL’s bytes; since 2026-11-04 reproduce computes exp, log, expf and logf as glibc 2.35 does and its default correctly rounded, GLIBC-07).
The tissue volumes of the partial-volume maps, both ports against the original: FSL fast 6.0.7.23 (ml)
| Run | CSF | grey matter | white matter | against FSL's |
|---|---|---|---|---|
| FSL fast 6.0.7.23 | 146.911 | 721.043 | 361.047 | the same |
| replica, reproduce | 146.911 | 721.043 | 361.047 | the same |
| replica, fix | 146.915 | 721.021 | 361.066 | differs (at most 0.0053 %) |
| fMRIPrep’s output (FSL in its image) | 146.911 | 721.043 | 361.047 | the same |
| FSL fast 6.0.7.23, correctly rounded maths | 146.911 | 721.011 | 361.079 | differs (at most 0.0089 %) |
| clean room, reproduce | 146.911 | 721.043 | 361.047 | the same |
| clean room, fix | 146.915 | 721.021 | 361.066 | differs (at most 0.0053 %) |
Each partial-volume map summed over every voxel in float64, times the voxel’s volume (1 mm³); fMRIPrep’s own maps are the node’s outputs in the run’s working directory (FSL in fMRIPrep 25.2.6’s image). the same: the three volumes equal FSL’s to the last digit of float64; otherwise the largest relative difference of the three.
Provenance of this example
- Data: OpenNeuro ds000228, sub-pixar008, CC0-1.0
- Inputs: T1w brain (sha256 3b9e5fb93cce231e…)
- Runs: figures cache entry
fsl-fast/fmriprep-ds000228-sub-pixar008-noreconall, computed 2026-11-02T21:21:25+00:00; 1 of its 4 runs made again since, last on 2026-11-03T21:54:48+00:00, with larmorx3b65d4eeb6c7; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in itsRUN_INFO.json - Runs: figures cache entry
fsl-fast/original-fmriprep-ds000228-sub-pixar008-noreconall, computed 2026-11-03T03:10:51+00:00; 3 of its 4 runs made again since, last on 2026-11-05T11:03:20+00:00, with larmorx92098004ac10; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); “larmorx 0.0.1 (the clean-room original, crate larmorx-fsl, Apache-2.0)”, as the cache entry records it; CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27); every command, its environment, threads and exit status are in itsRUN_INFO.json
Every number above is in fsl-fast.json, exported by python -m larmorx_validation evidence fsl-fast.
Worked example
Data panel: a glioma patient's T1w
What this shows: On the data panel’s glioma patient, the replica and the clean room both give FSL’s files, every value, and the same partial-volume maps as fMRIPrep’s own. In fix, their default, both correct FSL-202 (a class variance that loses most of its digits): the replica’s segmentation moves by 392 voxels and its mixel types by 453, and the two defaults differ only by the correctly rounded functions’ last bits, within FSL’s own band.
- Replica against FSL fast 6.0.7.23Bit-identical
- Clean room against FSL fast 6.0.7.23Bit-identical
The FAST node fMRIPrep 25.2.6 ran on a glioma patient’s T1w (ds005003): fast -I 0 -N -p -g -S 1 <T1w brain> (no bias field: fMRIPrep corrected it with N4 before; the posterior probabilities and the binary class images written too), given to FSL 6.0.7.23 (as built, and with correctly rounded maths), to the replica (larmorx-nc) in reproduce and in fix and at one thread, and to LARMORX’s clean room in reproduce and in fix at 14 threads and at one. Choose the output above the panels: the segmentation, the three partial-volume maps fMRIPrep keeps, the probabilities, the mixel types, the binary classes. Below the viewer, every file FAST writes and the tissue volumes the maps give, with fMRIPrep’s own. As a data-panel case beside the first example, it is stored as three full-resolution slices.
- Data
- OpenNeuro ds005003, sub-RS001 (CC0-1.0): the T1w brain fMRIPrep computed (skull-stripped, no face); shown inside its brain, dilated by 2 voxels (1,881 ml of brain)
- Node
- fMRIPrep 25.2.6,
work/fmriprep_25_2_wf/sub_RS001_ses_1_wf/anat_fit_wf/fast - Command
fast -I 0 -N -p -g -S 1 sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked.nii.gz- Programs
- FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH) (its run served from the cache of the original’s runs, as the record ran it); larmorx-nc 0.0.1 (the replica), from LARMORX at commit
3b65d4eeb6c7; the same FSL with CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27) (served from the cache of the original’s runs); LARMORX 0.0.1 (the clean room, crate larmorx-fsl, Apache-2.0), from LARMORX at commit92098004ac10 - Grid
- 144 × 256 × 256 voxels of 1.2 × 0.977 × 0.977 mm; shown: 127 × 193 × 167 around the brain
Data shown
- Retrospective Task/Rest fMRI Data from Tumor Patients (OpenNeuro ds005003, version 2.0.0, doi:10.18112/openneuro.ds005003.v2.0.0), CC0 1.0 public-domain dedication.




Bit-identical9,437,184 of 9,437,184 voxels equal
Bit-identical9,437,184 of 9,437,184 voxels equal

Axial slice 120 of 167; the three slices through the tumour are stored at full resolution (the replica agrees with FSL everywhere; the clean room's differences are sought in them). The interactive viewer needs JavaScript; the metrics below are complete without it.
Stored for this example: three full-resolution slices, one per plane, through display voxel (35, 122, 120): where the main comparison differs most, or the field's centre where nothing differs; every metric is computed over every voxel of the files.
Every comparison, computed in float64 over every voxel of the outputs
| Comparison (A − B), verdict and reason | Output | max |Δ| | Values that differ | RMS of Δ | max |Δ| ÷ range | 1 − NCC |
|---|---|---|---|---|---|---|
| The original against itself: the yardstick | ||||||
| FSL fast, correctly rounded maths − FSL as builtreferenceThe yardstick: FSL against itself with CORE-MATH’s correctly rounded exp, log, expf and logf preloaded into the same unmodified program, so how far FSL’s result moves when only those functions’ last bits change. FAST’s single-channel variance in the log domain cancels most digits, so such a change moves a few voxels of the smallest classes and mixel types. FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 2 | 357 of 9,437,184 (0.00378 %) | 0.00697 | 0.667 | 2.89e−5 |
| Partial volume: CSF | 1 | 3,296 of 9,437,184 (0.0349 %) | 0.00214 | 1 | 0.000112 | |
| Partial volume: GM | 1 | 7,126 of 9,437,184 (0.0755 %) | 0.00227 | 1 | 5.3e−5 | |
| Partial volume: WM | 1 | 3,968 of 9,437,184 (0.042 %) | 0.00241 | 1 | 4.21e−5 | |
| Classes of the partial volumes | 2 | 189 of 9,437,184 (0.002 %) | 0.00535 | 0.667 | 1.6e−5 | |
| Probability: CSF | 0.00345 | 1,510,952 of 9,437,184 (16 %) | 9.34e−5 | 0.00345 | 1.56e−7 | |
| Probability: GM | 0.00253 | 1,626,157 of 9,437,184 (17.2 %) | 0.000167 | 0.00261 | 2.7e−7 | |
| Probability: WM | 0.00364 | 1,498,942 of 9,437,184 (15.9 %) | 0.000194 | 0.00372 | 2.66e−7 | |
| Mixel type | 4 | 450 of 9,437,184 (0.00477 %) | 0.0213 | 0.8 | 0.000186 | |
| Binary: CSF | 1 | 84 of 9,437,184 (0.00089 %) | 0.00298 | 1 | 0.000159 | |
| Binary: GM | 1 | 323 of 9,437,184 (0.00342 %) | 0.00585 | 1 | 0.000271 | |
| Binary: WM | 1 | 307 of 9,437,184 (0.00325 %) | 0.0057 | 1 | 0.000227 | |
| The replica against the original | ||||||
| replica − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this call (the record compares its messages and exit status too). | every output | identical: 0 of 9,437,184 values differ | ||||
| replica − fMRIPrep's outputBit-identicalfMRIPrep’s own files (FSL in fMRIPrep 25.2.6’s image), the partial-volume maps and their segmentation its node keeps, hold the same values. | every output | identical: 0 of 9,437,184 values differ | ||||
| The replica against itself: thread counts, fix and reproduce | ||||||
| replica, 1 thread − 4 threadsBit-identicalThe thread count changes nothing (with -N there is no bias field, the only step the replica runs in threads). | every output | identical: 0 of 9,437,184 values differ | ||||
replica, fix − reproduceDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-03): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default squares the mean of a double-precision quotient in double precision. Measured on seven cases, fMRIPrep’s three calls among them, the default’s segmentation and mixel types lie 0 or 1 voxel from FAST computed with its class statistics in double precision throughout, where FSL’s lie 1 to 844 voxels from it, and its own last-bit band is 0 voxels where FSL’s reaches 3 to 807: most of FSL’s own band is this cancellation. reproduce gives FSL’s bytes (the row of reproduce against FSL in this table). FSL-202 FSL-96 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 392 of 9,437,184 (0.00415 %) | 0.00789 | 0.667 | 3.7e−5 |
| Partial volume: CSF | 1 | 2,319 of 9,437,184 (0.0246 %) | 0.0026 | 1 | 0.000165 | |
| Partial volume: GM | 1 | 5,193 of 9,437,184 (0.055 %) | 0.00235 | 1 | 5.7e−5 | |
| Partial volume: WM | 1 | 3,055 of 9,437,184 (0.0324 %) | 0.00283 | 1 | 5.82e−5 | |
| Classes of the partial volumes | 2 | 188 of 9,437,184 (0.00199 %) | 0.0059 | 0.667 | 1.95e−5 | |
| Probability: CSF | 0.0058 | 1,515,240 of 9,437,184 (16.1 %) | 0.000138 | 0.0058 | 3.6e−7 | |
| Probability: GM | 0.00286 | 1,626,000 of 9,437,184 (17.2 %) | 0.000181 | 0.00296 | 3.03e−7 | |
| Probability: WM | 0.006 | 1,498,788 of 9,437,184 (15.9 %) | 0.000243 | 0.00613 | 4.41e−7 | |
| Mixel type | 4 | 453 of 9,437,184 (0.0048 %) | 0.021 | 0.8 | 0.00018 | |
| Binary: CSF | 1 | 91 of 9,437,184 (0.000964 %) | 0.00311 | 1 | 0.000172 | |
| Binary: GM | 1 | 327 of 9,437,184 (0.00347 %) | 0.00589 | 1 | 0.000275 | |
| Binary: WM | 1 | 366 of 9,437,184 (0.00388 %) | 0.00623 | 1 | 0.000271 | |
| The clean room against the original and the replica | ||||||
| clean room − FSL fast 6.0.7.23Bit-identicalThe same values, every one, in every image FAST writes on this call. | every output | identical: 0 of 9,437,184 values differ | ||||
clean room − FSL fast, correctly rounded mathsWithin the original's own variabilityreproduce computes exp, log, expf and logf as glibc 2.35 does, as FSL’s build, so it gives FSL’s values as built, every one (the row of reproduce against FSL in this table); against FSL with correctly rounded maths its differences are therefore FSL’s own last-bit band, value for value (the yardstick row). FSL's own last-bit band | Classes (1 CSF, 2 GM, 3 WM) | 2 | 357 of 9,437,184 (0.00378 %) | 0.00697 | 0.667 | 2.89e−5 |
| Partial volume: CSF | 1 | 3,296 of 9,437,184 (0.0349 %) | 0.00214 | 1 | 0.000112 | |
| Partial volume: GM | 1 | 7,126 of 9,437,184 (0.0755 %) | 0.00227 | 1 | 5.3e−5 | |
| Partial volume: WM | 1 | 3,968 of 9,437,184 (0.042 %) | 0.00241 | 1 | 4.21e−5 | |
| Classes of the partial volumes | 2 | 189 of 9,437,184 (0.002 %) | 0.00535 | 0.667 | 1.6e−5 | |
| Probability: CSF | 0.00345 | 1,510,952 of 9,437,184 (16 %) | 9.34e−5 | 0.00345 | 1.56e−7 | |
| Probability: GM | 0.00253 | 1,626,157 of 9,437,184 (17.2 %) | 0.000167 | 0.00261 | 2.7e−7 | |
| Probability: WM | 0.00364 | 1,498,942 of 9,437,184 (15.9 %) | 0.000194 | 0.00372 | 2.66e−7 | |
| Mixel type | 4 | 450 of 9,437,184 (0.00477 %) | 0.0213 | 0.8 | 0.000186 | |
| Binary: CSF | 1 | 84 of 9,437,184 (0.00089 %) | 0.00298 | 1 | 0.000159 | |
| Binary: GM | 1 | 323 of 9,437,184 (0.00342 %) | 0.00585 | 1 | 0.000271 | |
| Binary: WM | 1 | 307 of 9,437,184 (0.00325 %) | 0.0057 | 1 | 0.000227 | |
| clean room − fMRIPrep's outputBit-identicalThe same values, every one. | every output | identical: 0 of 9,437,184 values differ | ||||
clean room, fix − FSL fast, correctly rounded mathsDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 83 of 9,437,184 (0.000879 %) | 0.00432 | 0.667 | 1.11e−5 |
| Partial volume: CSF | 1 | 1,047 of 9,437,184 (0.0111 %) | 0.00158 | 1 | 6.15e−5 | |
| Partial volume: GM | 1 | 1,989 of 9,437,184 (0.0211 %) | 0.00114 | 1 | 1.35e−5 | |
| Partial volume: WM | 1 | 1,005 of 9,437,184 (0.0106 %) | 0.00167 | 1 | 2.02e−5 | |
| Classes of the partial volumes | 2 | 63 of 9,437,184 (0.000668 %) | 0.00361 | 0.667 | 7.3e−6 | |
| Probability: CSF | 0.00236 | 1,508,956 of 9,437,184 (16 %) | 5.92e−5 | 0.00236 | 6.87e−8 | |
| Probability: GM | 0.000489 | 1,625,874 of 9,437,184 (17.2 %) | 3.66e−5 | 0.000506 | 9.32e−9 | |
| Probability: WM | 0.00236 | 1,498,074 of 9,437,184 (15.9 %) | 6.47e−5 | 0.00241 | 3.42e−8 | |
| Mixel type | 4 | 103 of 9,437,184 (0.00109 %) | 0.00902 | 0.8 | 3.33e−5 | |
| Binary: CSF | 1 | 55 of 9,437,184 (0.000583 %) | 0.00241 | 1 | 0.000104 | |
| Binary: GM | 1 | 52 of 9,437,184 (0.000551 %) | 0.00235 | 1 | 4.37e−5 | |
| Binary: WM | 1 | 59 of 9,437,184 (0.000625 %) | 0.0025 | 1 | 4.36e−5 | |
| clean room, fix − replica, fixWithin the original's own variabilityThe two defaults make the same corrections; the replica’s computes exp, log, expf and logf as glibc does, the clean room’s correctly rounded (with glibc’s functions in its default the two give the same bits: glibc_default.py). Partial volume: GM: 4 values differ (at most 0.01), FSL’s own 7,126 (at most 1); Partial volume: WM: 4 values differ (at most 0.01), FSL’s own 3,968 (at most 1); Classes of the partial volumes: 2 values differ (at most 1), FSL’s own 189 (at most 2); 3 more; no further, in any output, than FSL itself moves when only those functions’ last bits change (the yardstick row). findings | Classes (1 CSF, 2 GM, 3 WM) | 0 | 0 of 9,437,184 | 0 | 0 | 0 |
| Partial volume: CSF | 0 | 0 of 9,437,184 | 0 | 0 | 0 | |
| Partial volume: GM | 0.01 | 4 of 9,437,184 (4.24e−5 %) | 6.51e−6 | 0.01 | 4.37e−10 | |
| Partial volume: WM | 0.01 | 4 of 9,437,184 (4.24e−5 %) | 6.51e−6 | 0.01 | 3.07e−10 | |
| Classes of the partial volumes | 1 | 2 of 9,437,184 (2.12e−5 %) | 0.00046 | 0.333 | 1.19e−7 | |
| Probability: CSF | 5.36e−7 | 1,172,982 of 9,437,184 (12.4 %) | 1.47e−8 | 5.36e−7 | 3.67e−15 | |
| Probability: GM | 2.38e−7 | 1,181,860 of 9,437,184 (12.5 %) | 1.43e−8 | 2.47e−7 | 2.09e−15 | |
| Probability: WM | 5.36e−7 | 948,007 of 9,437,184 (10 %) | 1.62e−8 | 5.48e−7 | 2.14e−15 | |
| Mixel type | 0 | 0 of 9,437,184 | 0 | 0 | 0 | |
| Binary: CSF | 0 | 0 of 9,437,184 | 0 | 0 | 0 | |
| Binary: GM | 0 | 0 of 9,437,184 | 0 | 0 | 0 | |
| Binary: WM | 0 | 0 of 9,437,184 | 0 | 0 | 0 | |
| The clean room against itself: thread counts, fix and reproduce | ||||||
| clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the clean room’s parallel sweeps (a pipeline of planes in the serial order), blocked sums and sorts give its one-thread result bit for bit at any thread count. | every output | identical: 0 of 9,437,184 values differ | ||||
clean room, fix − reproduceDeliberate correctionFSL-202, corrected by default with a notice (since 2026-11-05): with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of the mean, that square of a single-precision mean rounded to single precision, so most of its digits cancel; the default subtracts the square of the double-precision mean. With glibc’s functions in place of the correctly rounded ones the default gives the replica’s default bit for bit on every single-channel case of the suite (glibc_default.py): the two corrections are the same arithmetic. Its reproduce follows FSL. It also computes exp, log, expf and logf correctly rounded (GLIBC-07, not named). FSL-202 | Classes (1 CSF, 2 GM, 3 WM) | 2 | 392 of 9,437,184 (0.00415 %) | 0.00789 | 0.667 | 3.7e−5 |
| Partial volume: CSF | 1 | 2,319 of 9,437,184 (0.0246 %) | 0.0026 | 1 | 0.000165 | |
| Partial volume: GM | 1 | 5,189 of 9,437,184 (0.055 %) | 0.00235 | 1 | 5.7e−5 | |
| Partial volume: WM | 1 | 3,051 of 9,437,184 (0.0323 %) | 0.00283 | 1 | 5.82e−5 | |
| Classes of the partial volumes | 2 | 186 of 9,437,184 (0.00197 %) | 0.00589 | 0.667 | 1.94e−5 | |
| Probability: CSF | 0.0058 | 1,515,240 of 9,437,184 (16.1 %) | 0.000138 | 0.0058 | 3.6e−7 | |
| Probability: GM | 0.00286 | 1,626,012 of 9,437,184 (17.2 %) | 0.000181 | 0.00296 | 3.03e−7 | |
| Probability: WM | 0.006 | 1,498,762 of 9,437,184 (15.9 %) | 0.000243 | 0.00613 | 4.41e−7 | |
| Mixel type | 4 | 453 of 9,437,184 (0.0048 %) | 0.021 | 0.8 | 0.00018 | |
| Binary: CSF | 1 | 91 of 9,437,184 (0.000964 %) | 0.00311 | 1 | 0.000172 | |
| Binary: GM | 1 | 327 of 9,437,184 (0.00347 %) | 0.00589 | 1 | 0.000275 | |
| Binary: WM | 1 | 366 of 9,437,184 (0.00388 %) | 0.00623 | 1 | 0.000271 | |
Δ is A − B, computed in float64 over all 9,437,184 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file FSL writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-fast) holds it to specs/fast.md §11’s thresholds instead: FSL’s exit status, files and messages (numbers to 4 significant digits); the label images per-class Dice ≥ 0.999 with ≥ 99.9 % of the mask’s voxels identical; the partial volumes’ mean |Δ| ≤ 0.001, 99.9th percentile ≤ 0.02, totals within 0.1 %; the probabilities’ mean |Δ| ≤ 0.001; the bias field and corrected image within 1e-4 relative at the 99.9th percentile.
Every image FAST writes, both ports against the original: FSL fast 6.0.7.23
| File | Type | Voxels | replica, reproduce | replica, fix | clean room, reproduce | clean room, fix | clean room − FSL fast, correctly rounded maths | clean room, fix − FSL fast, correctly rounded maths |
|---|---|---|---|---|---|---|---|---|
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_seg.nii.gz | int32 | 144 × 256 × 256 | identical | differs | data identical | 392 values differ | 357 values differ | 83 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_pve_0.nii.gz | float32 | 144 × 256 × 256 | identical | differs | data identical | 2,319 values differ | 3,296 values differ | 1,047 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_pve_1.nii.gz | float32 | 144 × 256 × 256 | identical | differs | data identical | 5,189 values differ | 7,126 values differ | 1,989 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_pve_2.nii.gz | float32 | 144 × 256 × 256 | identical | differs | data identical | 3,051 values differ | 3,968 values differ | 1,005 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_pveseg.nii.gz | int32 | 144 × 256 × 256 | identical | differs | data identical | 186 values differ | 189 values differ | 63 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_prob_0.nii.gz | float32 | 144 × 256 × 256 | identical | differs | data identical | 1,515,240 values differ | 1,510,952 values differ | 1,508,956 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_prob_1.nii.gz | float32 | 144 × 256 × 256 | identical | differs | data identical | 1,626,012 values differ | 1,626,157 values differ | 1,625,874 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_prob_2.nii.gz | float32 | 144 × 256 × 256 | identical | differs | data identical | 1,498,762 values differ | 1,498,942 values differ | 1,498,074 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_mixeltype.nii.gz | int32 | 144 × 256 × 256 | identical | differs | data identical | 453 values differ | 450 values differ | 103 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_seg_0.nii.gz | int32 | 144 × 256 × 256 | identical | differs | data identical | 91 values differ | 84 values differ | 55 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_seg_1.nii.gz | int32 | 144 × 256 × 256 | identical | differs | data identical | 327 values differ | 323 values differ | 52 values differ |
sub-RS001_ses-1_T1w_noise_corrected_corrected_xform_masked_seg_2.nii.gz | int32 | 144 × 256 × 256 | identical | differs | data identical | 366 values differ | 307 values differ | 59 values differ |
Each file decompressed and compared byte for byte with FSL’s: identical, the header (its descrip, FSL’s build string, aside) and every value; data identical, every value but not the header; differs, values that differ (see the comparisons above). For the clean room, where the values are not the same, how many of the file’s values differ: from FSL’s file, and in the last two columns from the file of FSL with correctly rounded maths (the record holds them to specs/fast.md §11’s thresholds, not to FSL’s bytes; since 2026-11-04 reproduce computes exp, log, expf and logf as glibc 2.35 does and its default correctly rounded, GLIBC-07).
The tissue volumes of the partial-volume maps, both ports against the original: FSL fast 6.0.7.23 (ml)
| Run | CSF | grey matter | white matter | against FSL's |
|---|---|---|---|---|
| FSL fast 6.0.7.23 | 279.281 | 699.382 | 902.574 | the same |
| replica, reproduce | 279.281 | 699.382 | 902.574 | the same |
| replica, fix | 279.385 | 699.44 | 902.412 | differs (at most 0.037 %) |
| fMRIPrep’s output (FSL in its image) | 279.281 | 699.382 | 902.574 | the same |
| FSL fast 6.0.7.23, correctly rounded maths | 279.385 | 699.428 | 902.424 | differs (at most 0.037 %) |
| clean room, reproduce | 279.281 | 699.382 | 902.574 | the same |
| clean room, fix | 279.385 | 699.44 | 902.412 | differs (at most 0.037 %) |
Each partial-volume map summed over every voxel in float64, times the voxel’s volume (1.144 mm³); fMRIPrep’s own maps are the node’s outputs in the run’s working directory (FSL in fMRIPrep 25.2.6’s image). the same: the three volumes equal FSL’s to the last digit of float64; otherwise the largest relative difference of the three.
Provenance of this example
- Data: OpenNeuro ds005003, sub-RS001, CC0-1.0
- Inputs: T1w brain (sha256 075ae3749c5e5025…)
- Runs: figures cache entry
fsl-fast/fmriprep-ds005003-sub-RS001-noreconall, computed 2026-11-02T21:23:01+00:00; 1 of its 4 runs made again since, last on 2026-11-03T21:55:19+00:00, with larmorx3b65d4eeb6c7; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in itsRUN_INFO.json - Runs: figures cache entry
fsl-fast/original-fmriprep-ds005003-sub-RS001-noreconall, computed 2026-11-03T03:10:58+00:00; 3 of its 4 runs made again since, last on 2026-11-05T11:03:27+00:00, with larmorx92098004ac10; FSL 6.0.7.23 (fsl-fast4 2111.3; ~/fsl-6.0.7.23, never on the PATH); “larmorx 0.0.1 (the clean-room original, crate larmorx-fsl, Apache-2.0)”, as the cache entry records it; CORE-MATH’s correctly rounded exp, log, expf, logf (the workspace’s preload, sha256 c4ba7f0c89812a27); every command, its environment, threads and exit status are in itsRUN_INFO.json
Every number above is in fsl-fast.json, exported by python -m larmorx_validation evidence fsl-fast.
Random testing after the catch-up
The clean-room catch-up’s random-testing run (2026-11-05) drew the earlier run’s cases again and further, on the clean room with the specification’s answers: 19,695 random calls in 30 minutes, each compared as the record compares (reproduce with FSL, the default with the replica’s default). 19,645 agreed. Each of the 50 that differed is in one category below:
- 39 differ only where the default is held to the replica’s default. With glibc’s functions in the default they are the replica’s bit for bit (identical with correctly rounded maths): the two defaults differ by the correctly rounded functions’ last bits alone. A 40th of that kind was not measured.
- 4 are a class covariance singular in exact arithmetic, where the matrix arithmetic’s last bits decide which program aborts.
- 6 are several channels whose run in
reproduceitself parts from FSL’s: 4 open, for FAST’s next clean-room part, and 2 whose noise-free channels make each class’s covariance ill-conditioned, explained before the catch-up.
Random testing, the clean room against the original: FSL fast 6.0.7.23 (19,695 random calls, 2026-11-05)
| Cases | |
|---|---|
| Random cases, each compared with FSL 6.0.7.23 | 19,695 |
| within the record’s thresholds (§11), every exact check passed | 19,645 |
| differing (each one in a category below) | 50 |
| fMRIPrep’s call (-I 0 -N -p -g -S 1) | 3,903 |
| two, three, four channels | 2,659 / 919 / 412 |
| FSL’s tissue priors (-a) | 1,814 |
| the bias field written (-b, -B) | 3,100 / 4,821 |
| -v | 1,597 |
| an output type other than NIFTI_GZ | 4,066 |
| distinct options and settings drawn | 33 |
| length (minutes; 14 jobs at one thread each) | 30 |
A random-testing run of the clean room, 30 minutes long, after the specification’s answers of 2026-11-03 (seed cleanroom-fast: the cases of the random-testing run of 2026-11-03 drawn again and further, FSL’s runs served by the cache of the original’s runs where they had run), each compared as the record compares (specs/fast.md §11: reproduce against FSL, the default against the replica’s default where one channel corrects FSL-202). The build: larmorx c798a295f9ca. Every case in a memory box of 3 GiB (peaks below 0.24 GiB).
The clean room’s differences from the original in that run, by category
| Category | Cases | Verdict | Reproducer |
|---|---|---|---|
| Only where the record holds the default to the replica’s default (a label image’s Dice 0.988 to 0.999, or a -v line in its 4th digit): with glibc’s exp, log, expf and logf in the default in place of the correctly rounded ones (glibc_default.patch), the replica’s default bit for bit, so the two defaults differ only by those functions’ last bits | 39 | Identical with correctly rounded maths | cleanroom-fast-01459-original |
Several channels whose run in reproduce itself parts from FSL’s (Dice 0.88 to 0.999): open, for FAST’s next clean-room part | 4 | Open difference | cleanroom-fast-15057-original |
| Several channels of which two are noise-free, so each class’s covariance is ill-conditioned: the partial volumes move with the matrix arithmetic’s last bits (explained before the catch-up; following LAPACK’s and OpenBLAS’s operation order is the replica’s job, specs/fast.md §8.6) | 2 | Open difference | cleanroom-fast-02215-original |
| A class covariance singular in exact arithmetic: the matrix arithmetic’s last bits decide which program aborts on inv(): matrix is singular, here the clean room (FSL finishes) | 2 | Open difference | cleanroom-fast-05605-original |
| A class covariance singular in exact arithmetic, where FSL aborts on inv(): matrix is singular (exit status -6) and the clean room’s arithmetic leaves it invertible and goes on (with FSLOUTPUTTYPE=ANALYZE to its output type’s refusal) | 2 | Expected divergence | cleanroom-fast-12578-original |
| The same check, two channels with -a priors: not measured with glibc’s functions (the patched build predates FLIRT’s changes) | 1 | Open difference | cleanroom-fast-02117-original |
Every differing case of the run in one category by its failed checks (validation/investigations/cleanroom-fast/trial_catchup_categories.py, its output validation/investigations/cleanroom-fast/trial_catchup_triage.json), each category’s cause established by replaying the findings (replay_findings.py, with glibc’s functions in the default: glibc_default.patch) and by probes (probe.py --finding --diff; docs/findings/fsl-fast-clean-room.md, “The catch-up’s random-testing trial”); the triage’s entries: validation/difftest/triage.toml. The reproducer is a finding of the run (difftest --replay).
Every case
Each case of the two records, the replica’s and the clean room’s, both against FSL 6.0.7.23 (a column each), with what it tests, its command line, each port’s verdict and the reason. The cases random testing gave each port are its own: three of the replica’s, five of the clean room’s. Search, filter by category or verdict (or select a segment of a chart above), sort by a column; #case=<name> links to one case.
105 cases
| Case | Category | What it tests | replica | clean room | Checks |
|---|---|---|---|---|---|
fmriprep/ds000005-sub-01-noreconall worked example | fMRIPrep's calls | fMRIPrep's segmentation call (ds000005-sub-01)command linefast -I 0 -N -p -g -S 1 <fMRIPrep's T1w brain> | Bit-identical every file FSL writes (13/13) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own files (its image’s FSL): 4/4 the same; in | Bit-identical Every value of all 12 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 12 of them, so glibc’s last bits matter here: | 7/7 · 16/16 |
fmriprep/ds000228-sub-pixar008-noreconall worked example | fMRIPrep's calls | fMRIPrep's segmentation call (ds000228-sub-pixar008)command linefast -I 0 -N -p -g -S 1 <fMRIPrep's T1w brain> | Bit-identical every file FSL writes (13/13) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own files (its image’s FSL): 4/4 the same; in | Bit-identical Every value of all 12 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 12 of them, so glibc’s last bits matter here: | 7/7 · 16/16 |
fmriprep/ds005003-sub-RS001-noreconall worked example | fMRIPrep's calls | fMRIPrep's segmentation call (ds005003-sub-RS001)command linefast -I 0 -N -p -g -S 1 <fMRIPrep's T1w brain> | Bit-identical every file FSL writes (13/13) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own files (its image’s FSL): 4/4 the same; in | Bit-identical Every value of all 12 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 12 of them, so glibc’s last bits matter here: | 7/7 · 16/16 |
real/fmriprep-call-half | real images | fMRIPrep's call (-I 0 -N -p -g -S 1) on ds000005's T1w brain at half resolutioncommand linefast -I 0 -N -p -g -S 1 <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (13/13) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 12 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 11 of them, so glibc’s last bits matter here: | 6/6 · 16/16 |
multi/s2-outputs | several channels | -S 2 (T1w, then T2w: the T2w is channel 1) with every output (-B -b -g -p)command linefast -S 2 -B -b -g -p -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (18/18) byte for byte, with FSL’s exit status and messages; FSL’s probability maps outside the mask, memory it never writes (FSL-96), set to 0 first in 1 file(s); in | Within the original's own variability In each of the 16 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 7/7 · 19/19 |
multi/s2-type2-verbose | several channels | -S 2 -t 2 -v: the T2w as channel 1 with the classes in reversed order, every messagecommand linefast -S 2 -t 2 -v -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages | Within the original's own variability In each of the 6 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 6/6 · 14/14 |
multi/s3 worked example | several channels | -S 3 (BOLD reference, T2w, T1w) with the bias field's outputs (3 x 3 matrices)command linefast -S 3 -B -b -o seg <mni_bold.nii.gz: MNI152NLin2009cAsym, derived> <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (15/15) byte for byte, with FSL’s exit status and messages | Within the original's own variability In each of the 12 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 6/6 · 16/16 |
multi/s4-n2 | several channels | -S 4 -n 2 (T1w/T2w ratio, BOLD reference, T2w, T1w: LAPACK's 4 x 4 paths), two classescommand linefast -S 4 -n 2 -p -o seg <mni_ratio.nii.gz: MNI152NLin2009cAsym, derived> <mni_bold.nii.gz: MNI152NLin2009cAsym, derived> <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (11/11) byte for byte, with FSL’s exit status and messages; FSL’s probability maps outside the mask, memory it never writes (FSL-96), set to 0 first in 1 file(s); its default, | Within the original's own variability In each of the 7 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 7/7 · 17/17 |
multi/s2-n4 | several channels | -S 2 -n 4: more than three classes (their own mixel types)command linefast -S 2 -n 4 -g -o seg <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (13/13) byte for byte, with FSL’s exit status and messages | Within the original's own variability In each of the 11 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 6/6 · 14/14 |
multi/s2-nopve-default-name | several channels | -S 2 --nopve without -o (the outputs named after channel 1)command linefast -S 2 --nopve <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages | Bit-identical Every value of all 1 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 1 of them, so glibc’s last bits matter here: | 6/6 · 12/12 |
multi/s2-nobias-outputs | several channels | -S 2 -N -B -b: no bias field, its outputs writtencommand linefast -S 2 -N -B -b -o seg <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (12/12) byte for byte, with FSL’s exit status and messages; FSL’s bias field, never computed (FSL-97), compared with the defined one; its default, | Within the original's own variability In each of the 10 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 7/7 · 17/17 |
multi/s2-manualseg | several channels | -S 2 -s: the initial class intensities from a file (three per channel)command linefast -S 2 -s <mni_means.txt: MNI152NLin2009cAsym, derived> -o seg <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (9/9) byte for byte, with FSL’s exit status and messages | Within the original's own variability In each of the 6 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 6/6 · 14/14 |
multi/s2-options | several channels | -S 2 with every numeric option (-I 2 -O 1 -W 5 -l 30 -f 0.05 -H 0.2 -R 0.5)command linefast -S 2 -I 2 -O 1 -W 5 -l 30 -f 0.05 -H 0.2 -R 0.5 -o seg <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages | Open difference Within the record’s thresholds (specs/fast.md §11), but in 1 of 6 images the clean room differs from FSL, and from FSL with correctly rounded maths, more than the two differ from each other: most | 6/6 · 14/14 |
multi/s2-quarter | several channels | -S 2 -B -b on the T1w and T2w at 4 mmcommand linefast -S 2 -B -b -o seg <mni4_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (12/12) byte for byte, with FSL’s exit status and messages | Bit-identical Every value of all 10 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 10 of them, so glibc’s last bits matter here: | 6/6 · 16/16 |
multi/s5 | several channels | -S 5 -B -b (T1w+T2w, T1w/T2w ratio, BOLD reference, T2w, T1w): 5 x 5 covariances (LAPACK's LU, inverse and solve beyond 4 x 4)command linefast -S 5 -B -b -o seg <mni_sum.nii.gz: MNI152NLin2009cAsym, derived> <mni_ratio.nii.gz: MNI152NLin2009cAsym, derived> <mni_bold.nii.gz: MNI152NLin2009cAsym, derived> <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (21/21) byte for byte, with FSL’s exit status and messages | Open difference Outside §11’s thresholds, explained: five channels of which the first is nearly a combination of the last two, so each class’s 5 × 5 covariance is nearly singular and its inverse amplifies the matrix arithmetic’s last bits; the clean room against itself with one rounding changed in the covariance’s products moves further (_mixeltype Dice 0.865) than it lands from FSL (0.907), and FSL with correctly rounded maths stays at FSL’s (0.99993). Following LAPACK’s and OpenBLAS’s operation order is the replica’s job (specs/fast.md §8.6). Segmentations (_seg, _seg_n, _pveseg, _mixeltype): Dice and identical voxels: seg_mixeltype.nii.gz: identical 0.95850, Dice 0.90691 (threshold Dice >= 0.999, identica… | 6/6 · 10/16 |
multi/s8 | several channels | -S 8 -n 2 -g: eight channels (the five, a square root, a product and a mix of the T1w and BOLD reference), 8 x 8 covariancescommand linefast -S 8 -n 2 -g -o seg <mni_mix.nii.gz: MNI152NLin2009cAsym, derived> <mni_prod.nii.gz: MNI152NLin2009cAsym, derived> <mni_sqrt.nii.gz: MNI152NLin2009cAsym, derived> <mni_sum.nii.gz: MNI152NLin2009cAsym, derived> <mni_ratio.nii.gz: MNI152NLin2009cAsym, derived> <mni_bold.nii.gz: MNI152NLin2009cAsym, derived> <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (15/15) byte for byte, with FSL’s exit status and messages | Bit-identical Every value of all 7 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types) | 6/6 · 14/14 |
multi/s0-error | several channels | -S 0: fewer than two channels (FAST's error)command linefast -S 0 <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits 1; the same from the replica. At least 2 channels required for Multi Channel Segmentation | Rejected by both fast exits 1; the same from the clean room. At least 2 channels required for Multi Channel Segmentation | 5/5 |
opt/bias-outputs worked example | options and images | the bias field (default) with -b -B -gcommand linefast -b -B -g -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (12/12) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 11 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 11 of them, so glibc’s last bits matter here: | 6/6 · 16/16 |
opt/type2-verbose | options and images | -t 2 -v: reversed class order, every messagecommand linefast -t 2 -v <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/type3-n2 | options and images | -t 3 -n 2 -g: PD-weighted, two classescommand linefast -t 3 -n 2 -g <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 7 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 7 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/n4-probs | options and images | -n 4 -p: four classes, their mixel typescommand linefast -n 4 -p -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (12/12) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 11 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 11 of them, so glibc’s last bits matter here: | 7/7 · 17/17 |
opt/n1 | options and images | -n 1 -v: one class (no mixel types)command linefast -n 1 -v -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages; its default, | Bit-identical Every value of all 4 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 6/6 · 14/14 |
opt/nopve | options and images | --nopve -g -Bcommand linefast --nopve -g -B -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 5 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 5 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/numeric | options and images | every numeric option (-I 2 -O 1 -W 5 -l 30 -f 0.05 -H 0.2 -R 0.5) with -bcommand linefast -I 2 -O 1 -W 5 -l 30 -f 0.05 -H 0.2 -R 0.5 -b -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 7 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 7 of them, so glibc’s last bits matter here: | 6/6 · 16/16 |
opt/H0-N | options and images | -H 0 -N: no MRF smoothness, no bias fieldcommand linefast -H 0 -N -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/long-names | options and images | the long option namescommand linefast --class=3 --iter=1 --lowpass=15 --type=1 --fHard=0.03 --segments --nobias --channels=1 --out=seg --init=3 --mixel=0.2 --fixed=2 --Hyper=0.15 --verbose <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (10/10) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 9 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 9 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/manualseg | options and images | -s: the initial class intensitiescommand linefast -s <t1_means.txt: written by the suite> -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/manualseg-cycle | options and images | -s with the classes in a cyclic order (sorted at the end)command linefast -s <t1_means_cycle.txt: written by the suite> -v -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/manualseg-two | options and images | -s with too few values (the percentiles instead)command linefast -s <t1_means_two.txt: written by the suite> -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/manualseg-missing | options and images | -s naming no file (the percentiles instead)command linefast -s nofile.txt -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/2d | options and images | a 2D image (one slice) with -B -bcommand linefast -B -b -o seg <t1_2d.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (9/9) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 8 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 8 of them, so glibc’s last bits matter here: | 6/6 · 16/16 |
opt/4d | options and images | a 4D image (its first volume, with newimage's warning)command linefast -o seg <t1_4d.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/offset | options and images | negative values, 2nd percentile below 0 (the minimum subtracted)command linefast -B -o seg <t1_offset.nii.gz: derived from ds000005's fMRIPrep run> | Rejected by both fast exits 255; the same from the replica. | Rejected by both fast exits 255; the same from the clean room. | 5/5 |
opt/negvox | options and images | a few negative voxels (set to 0)command linefast -B -o seg <t1_negvox.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 7 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 16/16 |
opt/nan-first | options and images | the negative voxels' image with a NaN first voxel (FSL-203: FSL's extrema NaN, the negative voxels kept and the mask empty: the k-means exception, exit 255; the default segments)command linefast -o seg <t1_nanfirst.nii.gz: derived from ds000005's fMRIPrep run> | Rejected by both fast exits 255; the same from the replica. The replica’s default, | Rejected by both An image whose first voxel is NaN, whose extrema FAST takes as NaN and whose brain mask is then empty, so its k-means stops with exit status 255 (FSL-203); since 2026-11-05 the clean room’s | 6/6 |
opt/nan | options and images | NaN voxels with -B -b -pcommand linefast -B -b -p -o seg <t1_nan.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (12/12) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 11 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 11 of them, so glibc’s last bits matter here: | 7/7 · 19/19 |
opt/int16 | options and images | a 16-bit integer imagecommand linefast -g -o seg <t1_int16.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (10/10) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 9 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 8 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/big | options and images | values above 2^24 (the brightest voxels and the mask)command linefast -g -o seg <t1_big.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (10/10) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 9 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 9 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/output-type | options and images | FSLOUTPUTTYPE=NIFTI_PAIRcommand lineFSLOUTPUTTYPE=NIFTI_PAIR fast -g -o seg <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (19/19) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 9 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 9 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
opt/default-name | options and images | no -o: the outputs named after the inputcommand linefast -N --nopve <t1_half.nii.gz: derived from ds000005's fMRIPrep run> | Bit-identical every file FSL writes (2/2) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 1 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 1 of them, so glibc’s last bits matter here: | 6/6 · 12/12 |
err/no-arguments | errors and odd values | no arguments: the usagecommand linefast | Rejected by both fast exits 1; the same from the replica. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | Rejected by both fast exits 1; the same from the clean room. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | 5/5 |
err/help | errors and odd values | -h: the usagecommand linefast -h | Rejected by both fast exits 1; the same from the replica. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | Rejected by both fast exits 1; the same from the clean room. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | 5/5 |
err/unknown-option | errors and odd values | an unknown optioncommand linefast --bogus <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits 1; the same from the replica. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | Rejected by both fast exits 1; the same from the clean room. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | 5/5 |
err/missing-value | errors and odd values | an option without its valuecommand linefast -n | Rejected by both fast exits 1; the same from the replica. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | Rejected by both fast exits 1; the same from the clean room. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | 5/5 |
err/bad-number | errors and odd values | a value that is not a numbercommand linefast -n abc <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits 1; the same from the replica. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | Rejected by both fast exits 1; the same from the clean room. Part of FSL (ID: 2412.6-dirty) FAST Copyright© 2004-2012, University of Oxford Usage: fast [options] file(s) Optional arguments (You may optionally specify one or more of): -n,–class number of tiss | 5/5 |
err/H-negative | errors and odd values | -H below 0command linefast -H -0.5 <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits 1; the same from the replica. ERROR: Segmentation smoothness must be positive. Exiting | Rejected by both fast exits 1; the same from the clean room. ERROR: Segmentation smoothness must be positive. Exiting | 5/5 |
err/H-nan | errors and odd values | -H nan (passes the check for a negative value)command linefast -H nan -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; its default, | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 10/10 |
err/H-inf | errors and odd values | -H infcommand linefast -H inf -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; its default, | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 6/6 · 10/10 |
err/l-zero | errors and odd values | -l 0 (no smoothing extent)command linefast -l 0 -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; its default, | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 6/6 · 10/10 |
err/f-nan | errors and odd values | -f nancommand linefast -f nan -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; its default, | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 6/6 · 10/10 |
err/R-nan | errors and odd values | -R nancommand linefast -R nan -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; its default, | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 10/10 |
err/n0 | errors and odd values | -n 0 (FAST aborts; FSL-99)command linefast -n 0 -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits -6; the same from the replica. terminate called after throwing an instance of ‘std::invalid_argument’ what(): Mixeltype exceeds allowed types The replica’s default, | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::invalid_argument’ what(): Mixeltype exceeds allowed types The clean room’s default, | 6/6 |
err/n-negative | errors and odd values | -n -1 (FAST aborts; FSL-99)command linefast -n -1 -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits -6; the same from the replica. terminate called after throwing an instance of ‘std::length_error’ what(): vector::_M_fill_insert The replica’s default, | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::length_error’ what(): vector::_M_fill_insert The clean room’s default, | 6/6 |
err/n-negative-multi | errors and odd values | -S 2 -n -2 (FAST aborts; FSL-99)command linefast -S 2 -n -2 -o seg <mni4_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits -6; the same from the replica. terminate called after throwing an instance of ‘std::logic_error’ what(): Mat::init(): requested size is too large The replica’s default, | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::logic_error’ what(): Mat::init(): requested size is too large The clean room’s default, | 6/6 |
err/n0-multi | errors and odd values | -S 2 -n 0 (FSL-99)command linefast -S 2 -n 0 -o seg <mni4_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages; its default, | Bit-identical Every value of all 3 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 7/7 · 10/10 |
err/n-minus2 | errors and odd values | -n -2 (FAST aborts; FSL-99)command linefast -n -2 <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits -6; the same from the replica. terminate called after throwing an instance of ‘std::length_error’ what(): vector::_M_default_append The replica’s default, | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::length_error’ what(): vector::_M_default_append The clean room’s default, | 6/6 |
err/l-negative | errors and odd values | -l -5 (FSL-99)command linefast -l -5 -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; its default, | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 6/6 · 10/10 |
err/missing-input | errors and odd values | an input that does not existcommand linefast -o seg nothere.nii.gz | Rejected by both fast exits -6; the same from the replica. Image Exception : #63 :: No image files match: nothere Image Exception : #22 :: Failed to read volume nothere.nii.gz Error : No image files match: nothere terminate called after throwing an instance o | Rejected by both fast exits -6; the same from the clean room. Image Exception : #63 :: No image files match: nothere Image Exception : #22 :: Failed to read volume nothere.nii.gz Error : No image files match: nothere terminate called after throwing an instance o | 5/5 |
err/option-after-input | errors and odd values | an option after the input (its value read as the image)command linefast -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> -n 2 | Rejected by both fast exits -6; the same from the replica. Image Exception : #63 :: No image files match: 2 Image Exception : #22 :: Failed to read volume 2 Error : No image files match: 2 terminate called after throwing an instance of ‘std::runtime_error’ wh | Rejected by both fast exits -6; the same from the clean room. Image Exception : #63 :: No image files match: 2 Image Exception : #22 :: Failed to read volume 2 Error : No image files match: 2 terminate called after throwing an instance of ‘std::runtime_error’ wh | 5/5 |
err/constant | errors and odd values | a constant image (k-means cannot start)command linefast -o seg <const.nii.gz: synthetic> | Rejected by both fast exits 255; the same from the replica. | Rejected by both fast exits 255; the same from the clean room. | 5/5 |
err/zeros | errors and odd values | an image of zeros (an empty mask)command linefast -o seg <zeros.nii.gz: synthetic> | Rejected by both fast exits 255; the same from the replica. | Rejected by both fast exits 255; the same from the clean room. | 5/5 |
err/fsldir-unset | errors and odd values | FSLDIR unset (no priors asked for: FAST aborts; FSL-100)command linefast -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> (FSLDIR unset) | Rejected by both fast exits -6; the same from the replica. terminate called after throwing an instance of ‘std::logic_error’ what(): basic_string: construction from null is not valid The replica’s default, | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::logic_error’ what(): basic_string: construction from null is not valid The clean room’s default, | 6/6 |
err/fsldir-unset-a | errors and odd values | FSLDIR unset with -a (FAST aborts; refused by default)command linefast -a <std2mni.mat: written by the suite> -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> (FSLDIR unset) | Rejected by both fast exits -6; the same from the replica. terminate called after throwing an instance of ‘std::logic_error’ what(): basic_string: construction from null is not valid The replica’s default, | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::logic_error’ what(): basic_string: construction from null is not valid The clean room’s default, | 5/5 |
err/fsldir-unset-A-a | errors and odd values | FSLDIR unset with -A and -a (FLIRT's command starts with (null): the shell fails and FAST crashes; FSL-102, FSL-101)command linefast -A <tpl_csf.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> <tpl_gm.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> <tpl_wm.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> -a <ident.mat: written by the suite> -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> (FSLDIR unset) | Rejected by both fast exits -11; the same from the replica. sh: 1: Syntax error: word unexpected sh: 1: Syntax error: word unexpected sh: 1: Syntax error: word unexpected csf prior image not transformed correctly! priors are not used! The replica’s default, | Rejected by both fast exits -11; the same from the clean room. sh: 1: Syntax error: word unexpected sh: 1: Syntax error: word unexpected sh: 1: Syntax error: word unexpected csf prior image not transformed correctly! priors are not used! The clean room’s default, | 6/6 |
err/S2-sizes | errors and odd values | -S 2 with images of different sizes, channel 1 the smaller (FAST aborts; FSL-104)command linefast -S 2 -v -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits -6; the same from the replica. Image Exception : #3 :: mask and vol have different sizes in calc_percentiles terminate called after throwing an instance of ‘std::runtime_error’ what(): mask and vol have different sizes in calc_perc The replica’s default, | Rejected by both fast exits -6; the same from the clean room. Image Exception : #3 :: mask and vol have different sizes in calc_percentiles terminate called after throwing an instance of ‘std::runtime_error’ what(): mask and vol have different sizes in calc_perc The clean room’s default, | 6/6 |
err/S2-sizes-larger-first | errors and odd values | -S 2 with images of different sizes, channel 1 the larger (refused; FSL-104)command linefast -S 2 -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Expected divergence undefined behaviour of FSL’s (FSL-104); refused. FSL exits -11: | Expected divergence undefined behaviour of FSL’s (FSL-104); refused | 2/2 |
err/S4-two-images | errors and odd values | -S 4 with two images (an option word read as an image)command linefast -S 4 <mni4_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits -6; the same from the replica. Image Exception : #63 :: No image files match: 4 Image Exception : #22 :: Failed to read volume 4 Error : No image files match: 4 terminate called after throwing an instance of ‘std::runtime_error’ wh | Rejected by both fast exits -6; the same from the clean room. Image Exception : #63 :: No image files match: 4 Image Exception : #22 :: Failed to read volume 4 Error : No image files match: 4 terminate called after throwing an instance of ‘std::runtime_error’ wh | 5/5 |
err/fsldir-unset-A | errors and odd values | FSLDIR unset with -A (no FSLDIR needed)command linefast -A a b c -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> (FSLDIR unset) | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
err/S1-two-images | errors and odd values | -S 1 with two images (the last one segmented)command linefast -o seg <mni4_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (8/8) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
priors/a-verbose worked example | FSL's tissue priors | -a with FSL's standard priors, -vcommand linefast -a <std2mni.mat: written by the suite> -v -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (11/11) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 9 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 3 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
priors/a-P-probs | FSL's tissue priors | -a -P: the priors throughout, -p -gcommand linefast -a <std2mni.mat: written by the suite> -P -p -g -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (17/17) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 15 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 2 of them, so glibc’s last bits matter here: | 7/7 · 17/17 |
priors/a-n2 | FSL's tissue priors | -a -n 2: two classescommand linefast -a <std2mni.mat: written by the suite> -n 2 -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (10/10) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 8 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); in | 6/6 · 14/14 |
priors/a-P-n2 | FSL's tissue priors | -a -P -n 2command linefast -a <std2mni.mat: written by the suite> -P -n 2 -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (10/10) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 8 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); in | 6/6 · 14/14 |
priors/a-n4 | FSL's tissue priors | -a -n 4 (priors serve 2 or 3 classes only)command linefast -a <std2mni.mat: written by the suite> -n 4 -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (9/9) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 7 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 7 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
priors/A-a | FSL's tissue priors | -A (ds000005's own maps in the template's space) with -a (the identity) and -Pcommand linefast -A <tpl_csf.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> <tpl_gm.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> <tpl_wm.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> -a <ident.mat: written by the suite> -P -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (14/14) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 9 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); in | 6/6 · 14/14 |
priors/A-alone | FSL's tissue priors | -A without -a (no priors)command linefast -A <tpl_csf.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> <tpl_gm.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> <tpl_wm.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (10/10) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
priors/P-alone | FSL's tissue priors | -P without -a (no priors)command linefast -P -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (7/7) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
priors/missing-prior | FSL's tissue priors | -A naming a missing prior with -acommand linefast -A nothere <tpl_gm.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> <tpl_wm.nii.gz: ds000005's fMRIPrep tissue maps in the template's space> -a <ident.mat: written by the suite> -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (10/10) byte for byte, with FSL’s exit status and messages; in | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 6 of them, so glibc’s last bits matter here: | 6/6 · 14/14 |
priors/bad-matrix | FSL's tissue priors | -a naming a missing matrix (FLIRT fails; FAST crashes: FSL-101)command linefast -a nothere.mat -o seg <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits -11; the same from the replica. Could not open matrix file nothere.mat matrix multiplication: incompatible matrix dimensions: 4x4 and 0x0 Could not open matrix file nothere.mat matrix multiplication: incompatible matrix dimensions: The replica’s default, | Rejected by both fast exits -11; the same from the clean room. Could not open matrix file nothere.mat matrix multiplication: incompatible matrix dimensions: 4x4 and 0x0 Could not open matrix file nothere.mat matrix multiplication: incompatible matrix dimensions: The clean room’s default, | 6/6 |
priors/name-blank | FSL's tissue priors | -o with a blank: FLIRT's command split by the shell (FSL-102)command linefast -a <std2mni.mat: written by the suite> -o 'my seg' <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | Rejected by both fast exits -11; the same from the replica. Unrecognised option s Unrecognised option s Unrecognised option s csf prior image not transformed correctly! priors are not used! The replica’s default, | Rejected by both fast exits -11; the same from the clean room. Unrecognised option s Unrecognised option s Unrecognised option s csf prior image not transformed correctly! priors are not used! The clean room’s default, | 6/6 |
priors/multi-a-P | FSL's tissue priors | -S 2 -a -P: the multi-channel segmentation with the priorscommand linefast -S 2 -a <std2mni.mat: written by the suite> -P -o seg <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (12/12) byte for byte, with FSL’s exit status and messages; in | Within the original's own variability In each of the 9 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 6/6 · 14/14 |
priors/multi-a-n2 | FSL's tissue priors | -S 2 -a -n 2command linefast -S 2 -a <std2mni.mat: written by the suite> -n 2 -o seg <mni_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (11/11) byte for byte, with FSL’s exit status and messages; in | Within the original's own variability In each of the 8 images the clean room differs from FSL in no more values, and by no more, than FSL with correctly rounded maths does (FSL’s own last-bit band): most | 6/6 · 14/14 |
multi/s2-opposite-contrasts | several channels | -S 2 -B -b on a phantom of opposite contrasts: classes paired across the channels start empty; every voxel ends in class 1, the bias field NaN (FAST exits 0)command linefast -S 2 -B -b -o seg <phantom_t2.nii.gz: synthetic> <phantom_t1.nii.gz: synthetic> | Bit-identical every file FSL writes (12/12) byte for byte, with FSL’s exit status and messages | Bit-identical Every value of all 10 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types) | 6/6 · 16/16 |
multi/s2-manualseg-cycle | several channels | -S 2 -s (T1w/T2w ratio, T1w) with the classes in a cyclic order (FSL-98)command linefast -S 2 -s <mni_means_cycle.txt: MNI152NLin2009cAsym, derived> -o seg <mni_ratio.nii.gz: MNI152NLin2009cAsym, derived> <mni_t1.nii.gz: MNI152NLin2009cAsym, derived> | Bit-identical every file FSL writes (9/9) byte for byte, with FSL’s exit status and messages; in | Expected divergence Both defaults correct FSL-98’s class order (a cycle here), so FSL’s own band (FSL with correctly rounded maths) is not this path’s; several channels have no FSL-202 (one channel’s), so their band is FSL’s own size, not the narrow one of the corrected variance… | 6/6 · 13/14 |
difftest/fsl101-empty-mask-runs-on | random testing | FSL-101 (FLIRT cannot write the registered priors: an output type FSL 6.0.7.23 refuses) on an image whose mask is empty: FAST runs on, as no voxel reads the priors it never allocated; reproduce now does the samecommand lineFSLOUTPUTTYPE=ANALYZE fast -a <random testing's input case/fsl-fast/fsl101-empty-mask-runs-on/mat> <random testing's input case/fsl-fast/fsl101-empty-mask-runs-on/ch1> | Rejected by both fast exits 1; the same from the replica. ERROR:: Unrecognised value (ANALYZE) of environment variable FSLOUTPUTTYPE Legal values are: NIFTI, NIFTI_PAIR, NIFTI2, NIFTI2_PAIR, NIFTI_GZ, NIFTI_PAIR_GZ, NIFTI2_GZ, NIFTI2_PAIR_GZ, NIFTI_ZST, NIFT The replica’s default, | – | 5/5 |
difftest/fsl101-multi-exception | random testing | FSL-101 with three channels whose first voxel is in the mask: FAST's bounds-checked access to the unallocated priors throws 'Out of Bounds (time index)' and aborts; reproduce now throws the samecommand lineFSLOUTPUTTYPE=ANALYZE fast -a <random testing's input case/fsl-fast/fsl101-multi-exception/mat> -S 3 <random testing's input case/fsl-fast/fsl101-multi-exception/ch3> <random testing's input case/fsl-fast/fsl101-multi-exception/ch2> <random testing's input case/fsl-fast/fsl101-multi-exception/ch1> | Rejected by both fast exits -6; the same from the replica. ERROR:: Unrecognised value (ANALYZE) of environment variable FSLOUTPUTTYPE Legal values are: NIFTI, NIFTI_PAIR, NIFTI2, NIFTI2_PAIR, NIFTI_GZ, NIFTI_PAIR_GZ, NIFTI2_GZ, NIFTI2_PAIR_GZ, NIFTI_ZST, NIFT The replica’s default, | – | 5/5 |
difftest/fsl101-verbose-before-crash | random testing | FSL-101 with -v: FAST prints 'Beginning prior-based initialisation' before it crashes on the priors it never allocated; reproduce now prints it before its refusalcommand lineFSLOUTPUTTYPE=ANALYZE fast --iter=6 -f 0.05 -B --nopve -v -a <random testing's input case/fsl-fast/fsl101-verbose-before-crash/mat> -P -o fast <random testing's input case/fsl-fast/fsl101-verbose-before-crash/ch1> | Rejected by both fast exits -11; the same from the replica. ERROR:: Unrecognised value (ANALYZE) of environment variable FSLOUTPUTTYPE Legal values are: NIFTI, NIFTI_PAIR, NIFTI2, NIFTI2_PAIR, NIFTI_GZ, NIFTI_PAIR_GZ, NIFTI2_GZ, NIFTI2_PAIR_GZ, NIFTI_ZST, NIFT The replica’s default, | – | 5/5 |
original/v-n0 | the clean room's own cases | -v -n 0: the loops without a class, then the abort in the partial volumes; standard output ends at the last flushed line (` BETA 0.1`, the unflushed heading lost: §7)command linefast -v -n 0 -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | – | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::invalid_argument’ what(): Mixeltype exceeds allowed types The clean room’s default, | 6/6 |
original/v-n0-nopve | the clean room's own cases | -v -n 0 --nopve: the loops' lines without a class and `total tissue 0`, exit 0command linefast -v -n 0 --nopve -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | – | Bit-identical Every value of all 1 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 10/10 |
original/v-n0-H-nan | the clean room's own cases | -v -n 0 -H nan: FSL-99's TOTAL lines and pairs without a class, then the abortcommand linefast -v -n 0 -H nan -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | – | Rejected by both fast exits -6; the same from the clean room. 0.05 0.05 0.1 0.1 0.15 0.15 0.2 0.2 0.25 0.25 0.3 0.3 0.35 0.35 0.4 0.4 0.45 0.45 0.5 0.5 0.55 0.55 0.6 0.6 0.65 0.65 0.7 0.7 0.05 0.05 0.1 0.1 0.15 0.15 0.2 0.2 0.25 0.25 0.3 0.3 0.35 0.35 0.4 0.4 0. The clean room’s default, | 6/6 |
original/multi-v-n0 | the clean room's own cases | -S 2 -v -n 0: several channels' loops without a class (empty CHANNEL lines), the partial-volume heading and `total tissue 0`, exit 0command linefast -S 2 -v -n 0 -o seg <mni4_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | – | Bit-identical Every value of all 3 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 10/10 |
original/v-n-negative | the clean room's own cases | -v -n -1: FAST prints the image lines, then abortscommand linefast -v -n -1 -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | – | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::length_error’ what(): vector::_M_fill_insert The clean room’s default, | 6/6 |
original/multi-v-n-negative | the clean room's own cases | -S 2 -v -n -2: the heading, then the abortcommand linefast -S 2 -v -n -2 -o seg <mni4_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | – | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::logic_error’ what(): Mat::init(): requested size is too large The clean room’s default, | 6/6 |
original/v-S0 | the clean room's own cases | -S 0 -v: the multi-channel heading before the channels' errorcommand linefast -S 0 -v <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> | – | Rejected by both fast exits 1; the same from the clean room. At least 2 channels required for Multi Channel Segmentation | 5/5 |
original/v-missing-input | the clean room's own cases | -v with an image that cannot be read: the heading is printed before it is readcommand linefast -v -o seg nothere.nii.gz | – | Rejected by both fast exits -6; the same from the clean room. Image Exception : #63 :: No image files match: nothere Image Exception : #22 :: Failed to read volume nothere.nii.gz Error : No image files match: nothere terminate called after throwing an instance o | 5/5 |
original/v-fsldir-unset | the clean room's own cases | -v with FSLDIR unset: the image lines, then FSL-100's abortcommand linefast -v -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> (FSLDIR unset) | – | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::logic_error’ what(): basic_string: construction from null is not valid The clean room’s default, | 6/6 |
original/multi-v-fsldir-unset | the clean room's own cases | -S 2 -v with FSLDIR unset: the heading, then FSL-100's abortcommand linefast -S 2 -v -o seg <mni4_t2.nii.gz: MNI152NLin2009cAsym, derived> <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> (FSLDIR unset) | – | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::logic_error’ what(): basic_string: construction from null is not valid The clean room’s default, | 6/6 |
original/v-fsldir-unset-n-negative | the clean room's own cases | -v -n -1 with FSLDIR unset: FSL-100's abort comes firstcommand linefast -v -n -1 -o seg <mni4_t1.nii.gz: MNI152NLin2009cAsym, derived> (FSLDIR unset) | – | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::logic_error’ what(): basic_string: construction from null is not valid The clean room’s default, | 6/6 |
original/nan-no-negative | the clean room's own cases | NaN voxels in an image without a negative value: §4.1's rule skipped, `_restore` NaN there (§4.1.1)command linefast -B -b -o seg %t1_nan_noneg.nii.gz | – | Bit-identical Every value of all 8 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 8 of them, so glibc’s last bits matter here: | 16/16 |
original/nan-offset | the clean room's own cases | NaN voxels in an image whose 2nd percentile is negative: the minimum subtracted, `_restore` NaN there (§4.1.1)command linefast -B -o seg %t1_nan_offset.nii.gz | – | Bit-identical Every value of all 7 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); FSL with correctly rounded maths differs in 7 of them, so glibc’s last bits matter here: | 16/16 |
difftest/bias-nan-outside-mask | random testing | a class of NaN variance makes the bias field's mean NaN: FSL's field, _restore and _bias are NaN outside the mask too (b · M)command lineFSLOUTPUTTYPE=NIFTI2_GZ fast -B <random testing's input case/fsl-fast-original/bias-nan-outside-mask/ch1> | – | Bit-identical Every value of all 7 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 16/16 |
difftest/fsl101-verbose-line | random testing | FSL-101 reproduced with -v: 'Beginning prior-based initialisation' before FAST crashescommand lineFSLOUTPUTTYPE=ANALYZE fast -n 2 -l 10 -g -B -v -a <random testing's input case/fsl-fast-original/fsl101-verbose-line/mat> -o t1_brain <random testing's input case/fsl-fast-original/fsl101-verbose-line/ch1> | – | Rejected by both fast exits -11; the same from the clean room. ERROR:: Unrecognised value (ANALYZE) of environment variable FSLOUTPUTTYPE Legal values are: NIFTI, NIFTI_PAIR, NIFTI2, NIFTI2_PAIR, NIFTI_GZ, NIFTI_PAIR_GZ, NIFTI2_GZ, NIFTI2_PAIR_GZ, NIFTI_ZST, NIFT The clean room’s default, | 5/5 |
difftest/multi-class-without-weight | random testing | two channels, four classes, -v: a class without weight zeroes every posterior and its covariance is 0/0; the bias weights 0 / NaN make the field and then every mean NaN (FSL prints MEAN 1, then MEAN -nan; specs/fast.md §5.3)command lineFSLOUTPUTTYPE=NIFTI_GZ fast -n 4 --type=2 -H 0.4 -g -v -o t1_brain --channels=2 <random testing's input case/fsl-fast-original/multi-class-without-weight/ch2> <random testing's input case/fsl-fast-original/multi-class-without-weight/ch1> | – | Bit-identical Every value of all 11 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types) | 14/14 |
difftest/singular-kmeans-line | random testing | -v with several channels and a singular covariance: FSL aborts without the iteration's 'KMeans Iteration' linecommand lineFSLOUTPUTTYPE=NIFTI_PAIR fast -v -S 2 <random testing's input case/fsl-fast-original/singular-kmeans-line/ch2> <random testing's input case/fsl-fast-original/singular-kmeans-line/ch1> | – | Rejected by both fast exits -6; the same from the clean room. terminate called after throwing an instance of ‘std::runtime_error’ what(): inv(): matrix is singular | 5/5 |
difftest/zstd-outputs | random testing | FSLOUTPUTTYPE=NIFTI_ZST: the suite reads FSL's and the clean room's zstd images (it raised before)command lineFSLOUTPUTTYPE=NIFTI_ZST fast <random testing's input case/fsl-fast-original/zstd-outputs/ch1> | – | Bit-identical Every value of all 6 images FSL writes, with FSL’s exit status and messages (the record checks the headers’ grid, forms and data types); its default, | 14/14 |
Speed
FSL’s fast is single-threaded. On fMRIPrep’s call the clean room takes 2.4 to 5.2 s on one thread, 9 to 11 times as fast as FSL, and 0.4 to 0.9 s on 14 threads, 47 to 67 times as fast. The replica, a translation, is 1.4 to 1.9 times as fast as FSL’s build (the report). These timings are informal: one run each, on a machine running other work beside them; FSL’s time is that of its run stored in the cache of the original’s runs, not run again. The clean room’s results are the same bits at any thread count. Its peak memory on fMRIPrep’s call, as the memory test measures it at one thread, is 152 MiB, against FSL’s 707.
fast 6.0.7.23Seconds for fMRIPrep’s whole call (reading the T1w brain, segmenting, writing its twelve images), one run each, on a log scale. The factor is how many times faster the clean room is than FSL, both on one thread.
- FSL fast 6.0.7.23, 1 thread
- replica, 1 thread
- clean room, 1 thread
- clean room, 14 threads
- an adult's T1w (ds000005): 761,924 voxels in the maskFSL fast 6.0.7.23, 1 thread 21.9 sreplica, 1 thread 15.2 sclean room, 1 thread 2.43 sclean room, 14 threads 0.39 s9×
- a 3.5-year-old's T1w (ds000228): 1,229,002 voxels in the maskFSL fast 6.0.7.23, 1 thread 34 sreplica, 1 thread 23.3 sclean room, 1 thread 3.76 sclean room, 14 threads 0.73 s9×
- a glioma patient's T1w (ds005003): 1,643,850 voxels in the maskFSL fast 6.0.7.23, 1 thread 59.6 sreplica, 1 thread 31.3 sclean room, 1 thread 5.21 sclean room, 14 threads 0.89 s11×
From the benchmark report docs/benchmarks/fsl-fast.json (AMD Ryzen 9 7945HX, 32 logical CPUs, shared with other work: informal, one run each). FSL’s time is that of its run stored in the cache of the original’s runs, not run again; the replica’s images are FSL’s byte for byte, the clean room’s within its record’s thresholds and the same at any thread count.
Corrections by default
The replica corrects FSL’s deterministic defects by default, fix, and warns. upstream_defects="reproduce" (on the command line --upstream-defects reproduce from the next release, LARMORX_UPSTREAM_DEFECTS=reproduce in 0.1.0rc1) gives FSL’s behaviour byte for byte, where FSL’s behaviour is defined (register).
-p’s probability maps outside the brain mask (and everywhere with--nopveand priors, or without an initialisation iteration) are memory FAST never writes. The replica writes 0 there infixand inreproduceand names it (FSL-96). fMRIPrep’s call meets it: FSL’s maps held zeros there in its three runs of the record; in two multi-channel cases one file held other values, which the record sets to 0 before comparing.- With several channels and
-N, the bias field that-bsaves and-Bdivides by is never computed: no field, infixand inreproduce(FSL-97). - With several channels, FAST’s sort of the classes gives a class another class’s covariance and posteriors when the classes move in a cycle (given intensities in a cyclic order, for example): each class keeps its own by default (FSL-98).
- A smoothness that is not a number, a bias smoothing of 0 or less and fewer than one class are refused by default, with the reason (FSL-99); FAST uses them as given or aborts.
- FAST aborts when
FSLDIRis unset, even without priors: the replica segments (FSL-100). - When FLIRT cannot register the priors, FAST says they are not used and then crashes on priors it never allocated: the replica segments without them (FSL-101).
-aruns FLIRT through the shell with the names unquoted: the replica passes each name whole (FSL-102).- The brain mask leaves out the voxels of the image’s maximum when it is 224 or more: corrected (FSL-103).
- Channels of different sizes, which FAST reads past their ends, are refused in
fixand inreproduce(FSL-104). - Since 2026-11-03, with the specification’s answers to the clean room’s questions: with one channel, FAST takes each class’s variance in the logarithm of the intensities as the mean of the squares minus the square of a single-precision mean, which cancels most of its digits. The replica’s default squares the mean in double precision (FSL-202). It changes the default outputs of fMRIPrep’s call, toward the exactly computed statistics, as the examples show.
- Also since 2026-11-03: an image whose first voxel is NaN gives FAST NaN intensity extrema and an empty brain mask, and FAST stops with exit status 255. The replica’s default takes the extrema over the values that are numbers and segments it (FSL-203).
- Inside
-a, FLIRT’s replica corrects its own defects too (FSL-09, above).
The clean room makes the same corrections by default, with the same notices (FSL-202 and FSL-203 since 2026-11-05). Its reproduce follows FSL where FSL’s behaviour is defined: for a NaN -H, FAST’s estimate of the smoothness; FSL-98’s pairing; FSL-101’s runs and aborts; FSL-102’s split of the names; FSL-104 refused in fix and in reproduce. Inside -a, FLIRT’s clean room corrects FSL-09 as the replica does. Its default also computes exp and log correctly rounded, and its reproduce as glibc 2.35 does (GLIBC-07, named nowhere: The C library’s last digits, above).
Known limits
Both ports are experimental. Each record’s standard comparison holds fMRIPrep’s calls on three fMRIPrep runs. The full comparisons (fMRIPrep’s call on every fMRIPrep run), the data panel’s other images and the long random-testing runs come in the final validation phase.
The clean room is held to thresholds, not to FSL’s bytes. With several channels its own matrix arithmetic leaves a few partial volumes one fraction step from FSL’s, and nearly singular covariances (five channels, the first nearly a combination of the last two) are decided by the arithmetic’s last bits. The single-channel variance in the logarithm of the intensities cancels most digits, which makes FSL’s own band wide on small classes. Measured since (2026-11-03), it is a defect of FAST, FSL-202, corrected by default in both ports: the clean room’s since 2026-11-05, held to the replica’s default.
Open from the catch-up’s random-testing run: which program aborts on a class covariance singular in exact arithmetic, and several channels whose run in reproduce parts from FSL’s (four random cases).
More than eight channels (-S 9 and more): the clean room segments them. The replica refuses them in fix and in reproduce, with a message: FSL’s results there follow OpenBLAS’s kernels for larger matrices, which it does not reproduce. With several channels whose covariances turn NaN (an empty class), a NaN can carry other payload bits than FSL’s; the values and their NaN-ness are FSL’s.
Two behaviours of the multi-channel segmentation are kept as FAST’s until they are measured on real T1w and T2w pairs. One is its initialisation, which pairs each channel’s classes in the order of that channel’s own intensities: channels of opposite contrast can start from empty classes, and FAST then ends with every voxel in one class. The other is its bias field.
The cross-platform checks (how they work) hold the other five platforms to LARMORX’s own Linux output; the clean room’s cover fMRIPrep’s call, the bias field, two channels, the priors, the defects’ switches and a 2D image. The benchmark is informal: one run each, on a shared machine.
History
- 2026-11-02: the replica, translated from FSL 6.0.7.23’s source.
- 2026-11-03: the clean room, written from specs/fast.md, the paper and runs of FSL; its first random-testing run, 9,005 calls in 25 minutes. The specification’s answers to its questions the same day (§12): the replica’s default corrects FSL-202 and FSL-203 since, and its record of 87 cases.
- 2026-11-04: the clean room’s
reproducecomputesexp,log,expfandlogfas glibc 2.35 does (GLIBC-07): 36 cases moved from identical with correctly rounded maths to bit-identical, fMRIPrep’s three calls among them. - 2026-11-05: the clean-room catch-up. The specification’s answers of 2026-11-03 are in the clean room since: its default corrects FSL-202 and FSL-203, held to the replica’s default; 13 cases of its own; its record made again, 102 cases; the random-testing run of 19,695 calls.
Data credits
The data this page shows or names: each dataset with its version, DOI and licence, from LARMORX's test-data catalog. Public-domain dedications (CC0, PDDL) ask nothing; the datasets are cited all the same.
- Mixed-gambles task (OpenNeuro ds000005, version 00001), Open Data Commons Public Domain Dedication and Licence 1.0.
- Children and adults watching a short film (OpenNeuro ds000228, version 1.1.1, doi:10.18112/openneuro.ds000228.v1.1.1), CC0 1.0 public-domain dedication.
- Retrospective Task/Rest fMRI Data from Tumor Patients (OpenNeuro ds005003, version 2.0.0, doi:10.18112/openneuro.ds005003.v2.0.0), CC0 1.0 public-domain dedication.
- MNI152NLin2009cAsym template (TemplateFlow, version tpl-MNI152NLin2009cAsym git 15d7c02160f79f5218d2545b4febebeecc11531d), the MNI ICBM 152 copyright notice.