Research software reads formats that predate most of the web and rarely come with a clean sample. This category ships small, valid, fully synthetic ones. Chemistry covers MDL molfiles and SDfiles, XYZ coordinates, SMILES strings, crystallographic CIF, and PDB structures for an invented molecule. Bioinformatics covers FASTA and FASTQ sequences with documented quality encodings, SAM alignments, BED intervals, GFF3 annotations, and Newick phylogenetic trees. Numerical and gridded data arrive as NetCDF, HDF5, FITS, and Matrix Market alongside CSV twins so a loader can be checked against readable values. Citation formats (BibTeX, RIS) complete the set. Nothing here describes a real sample, organism, patient, or observation — the values are generated from fixed seeds and documented in each file's spec.
Filter scientific on Browse · 128 files · 11 subcategories
Every element of the float64 .npy array written as its shortest round-tripping decimal representation, one row per element in C order. Parsing this text back to float64 reproduces the binary array bit for bit, so it is a usable oracle rather than a lossy printout.
A 6x10 boolean mask stored as one byte per element, because .npy does not bit-pack booleans however tempting that assumption is. The True cells follow a simple divisible-by-three rule so a mis-decode is obvious rather than plausible.
A 4x6 matrix of 0..23 stored row-major, so the byte sequence begins with the first row. It is one half of a memory-order pair that is indistinguishable from its twin unless the header's fortran_order flag is honoured.
The real FFT of a 64-sample sine stored as complex128, where each element is an interleaved pair of doubles rather than two separate planes. Readers without a complex type usually flatten it, which doubles the reported length and shifts the peak bin.
Five timestamps stored as datetime64 with second resolution, where the unit is part of the dtype descriptor and the values on disk are plain int64 epoch seconds. Dropping the unit turns 2026-01-01 into the integer 1767225600 without any complaint.
Every structurally interesting float16 value in one array: one plus epsilon, the largest finite value, the smallest normal and subnormal, negative zero, infinity and a NaN. It is the compact half-precision counterpart to the float32 and float64 boundary fixtures.
The identical temperature field carried by the CF NetCDF and HDF5 fixtures, stored as a bare float32 .npy. Comparing the three shows exactly what a plain array container loses: the numbers survive, the units and axes do not.
The baseline .npy fixture: a 12x8 float64 array in version 1.0 format with a little-endian descriptor and the header padded to the mandatory 64-byte alignment. Every other array in this family varies exactly one property away from it.
Seven doubles written big-endian, including negative zero and values at both ends of the exponent range. Byte-swapping a double is unrecoverable by inspection — swap pi and you get 3.2e-192, which looks like a plausible tiny number rather than an error.
The same 4x6 matrix stored column-major with fortran_order set to True in the header. Ignoring that one boolean does not produce an error, it produces a transposed matrix — the quietest failure in the whole .npy format.
The same nine int16 values written big-endian, so the header descriptor reads '>i2'. A loader that ignores the descriptor and assumes native little-endian order returns 13330 where the file says 4660, without any error.
Nine int16 values including both type extremes, stored little-endian so the descriptor in the header reads '<i2'. It is one half of an endian pair whose values are identical and whose bytes are not.
A 16-record structured array carrying a value, its uncertainty and a quality flag, with the physical unit encoded in the field-name suffix because .npy has nowhere else to put it. The header descriptor is a list of field tuples rather than a single type string, which is the parsing branch this file exercises.
A rank-0 .npy holding a single double, whose header shape is the empty tuple rather than (1,). Indexing it with [0] raises rather than returning the value, so it separates parsers that model rank properly from parsers that assume at least one axis.
A valid .npy file with a full header, a declared (0, 4) shape and a data section of zero bytes. It preserves the column count across an empty result, and it separates readers that model emptiness from readers that treat it as failure.
A 300-field structured array whose descriptor is too long for a version 1.0 header, forcing format version 2.0 and its four-byte header-length field. A hand-rolled parser that assumes the two-byte 1.0 field mis-locates the data section entirely.
A structured array whose field names use Greek and CJK characters, which is the only reason format version 3.0 exists: its header is UTF-8 where 1.0 and 2.0 are latin-1. A parser that decodes the header as latin-1 mangles all three names.
The identical five arrays bundled with deflate instead of stored, which is the only difference between NumPy's savez and savez_compressed. Loading both and comparing proves a reader ran the decompressor rather than trusting stored-size shortcuts.
An npz-style bundle: a ZIP whose members are .npy files, which is exactly what NumPy's savez produces. np.load opens it by ZIP magic rather than by extension, so the arrays load straight from this .zip; rename it to .npz for tooling that checks the suffix.
The same six features as the GFF3 file expressed in BED's 0-based half-open coordinates, where the start is one lower and the end is unchanged. Confusing the two conventions shifts every interval by a base, and this pair makes that shift a visible diff.
The same four contigs written one sequence per line rather than wrapped, which is how many pipelines emit FASTA and how many line-oriented parsers assume it always looks. Comparing against the wrapped twin proves a parser joins continuation lines instead of taking the first one.
Four 600-base synthetic contigs wrapped at the conventional 60 columns, with the length and an invented organism name in each header. The sequences come from a fixed seed, so they are reproducible and belong to nothing that exists.
Every twelfth base of the six reads with its Phred score, the ASCII character it takes under both offsets, and the error probability that score implies. It converts a quality-encoding argument into a lookup you can diff.
Six 60-base reads with Phred+33 quality strings, the modern Sanger encoding used by everything since Illumina 1.8. Quality declines along each read the way real sequencing does, so a mis-decoded offset produces implausible scores rather than plausible ones.
The identical reads and identical quality scores written with the legacy Phred+64 offset used by older Illumina pipelines. Decode it with the modern offset and every base looks 31 points better than it is, which is a silent quality inflation rather than a parse failure.
Every interval written in both coordinate conventions with its length, which is identical either way. It is the lookup table for the most common bioinformatics off-by-one, and the length column is what proves a conversion did not quietly change an interval's size.
Seven features on a synthetic contig — two genes, an mRNA, two exons and two CDS records — linked by ID and Parent attributes across both strands. GFF3 coordinates are 1-based and inclusive, which is the fact its BED twin exists to contrast.
An intentionally corrupt FASTQ whose first five records are complete and whose sixth ends after the plus line, leaving no quality string. A four-line-block reader must report an incomplete final record rather than pairing the sequence with an empty quality string.
A six-taxon Newick tree with branch lengths on every edge and bootstrap-style support values written as internal node labels. That support notation is ambiguous by design in Newick — the same position can hold a node name — which is precisely what a parser has to decide about.
The identical tree topology with every branch length and support value stripped, which is what a Newick writer produces when the source tree has no lengths. Comparing the two proves a parser distinguishes 'length zero' from 'no length recorded'.
Three synthetic protein sequences that begin with methionine and include the X, B and Z ambiguity codes, which are legal IUPAC residues rather than errors. A validator restricted to the twenty standard amino acids rejects all three files.
Six alignments against a synthetic contig with a full @HD/@SQ/@RG/@PG header, both strands via the reverse flag, and CIGAR strings covering match, soft clip, insertion and deletion. Reference span and query length come apart in three of the records, which is where CIGAR arithmetic gets tested.
Each alignment's CIGAR decomposed into how many query bases and how many reference bases it consumes, with the resulting 1-based reference end. The three records where those numbers differ are the whole reason CIGAR arithmetic is worth testing.
Benzene written in the V3000 extended format, where the legacy counts line reports zero atoms and the real counts live in an M V30 COUNTS record. A parser that trusts the old counts line reads an empty molecule and reports no error whatsoever.
One row per molecule used across the chemistry fixtures, with formula, molecular weight, SMILES and the atom and bond counts each file should yield. It is the oracle a cheminformatics toolkit can be scored against without needing a second toolkit to generate the answers.
A CIF built entirely out of the constructs that break naive parsers: quoted values containing apostrophes and hashes, a semicolon-delimited multi-line text field, the distinct '?' and '.' markers, a standard uncertainty written as 1.2345(7), and a loop whose rows wrap across lines. Every one of them is legal CIF.
Ethanol as a V2000 molfile with fixed-column 3D coordinates, a nine-atom counts line and an eight-bond block. The column widths are part of the format rather than a convention, so it is a genuine test of fixed-width parsing rather than of whitespace splitting.
An SDfile wrapping the identical ethanol molfile plus five tagged data fields and the mandatory $$$$ terminator. The property block syntax — a header line, a value and a blank line — is where SDfile parsers usually diverge from molfile parsers.
Ethanol as a single tab-delimited SMILES record, the most compressed member of this family: three heavy atoms with every hydrogen implicit and no geometry whatsoever. Round-tripping molfile to SMILES and back is the classic lossy conversion, and this pair is the reference for it.
The same ethanol geometry in XYZ format: an atom count, a free-text comment line and one line of element and coordinates per atom. XYZ carries no connectivity at all, so converting to it from the molfile is a lossy operation that this pair makes measurable.
Five concatenated XYZ frames of the same ethanol molecule rotated rigidly about z in 15-degree steps, which keeps every interatomic distance constant. Frames are separated only by the next atom-count line, so a reader that expects a blank-line delimiter stops after frame one.
A single-data-block CIF describing an idealised rock-salt lattice: cell parameters, space group, a symmetry-operation loop and an atom-site loop with fractional coordinates and occupancies. The '?' in the temperature field is CIF's marker for unknown, which is not the same as an empty value.
An intentionally corrupt molfile whose counts line declares twelve atoms while the atom block contains nine, so a parser reading by count consumes three bond lines as atoms. Everything else about the file is well formed, which is what makes the failure quiet.
Ten tab-delimited SMILES covering the notation features that trip parsers: lowercase aromatic atoms, ring-closure digits, branch parentheses, explicit charges in brackets and a dot-disconnected salt. Every structure is small enough to verify by hand.
Three molecules of different sizes in one SDfile, each with its own connection table and four data fields, separated by the $$$$ terminator. It is the fixture for streaming SDfile readers that have to split on the terminator rather than load the whole file.
A FITS binary table with four typed columns, big-endian numerics packed with no inter-field padding and TUNIT declaring milli-jansky on the two flux columns. It is the fixture for a table reader that has to build a row struct from TFORM codes rather than guess widths.
Integer FITS images mark undefined pixels with the BLANK keyword, and BLANK is compared against the stored value before BZERO and BSCALE are applied. Scale first and the four undefined pixels turn into a perfectly plausible zero, which is the ordering bug this file exists to expose.
A completely valid FITS file consisting of one 2880-byte header block and no data unit, which the standard permits whenever NAXIS is 0. It separates readers that model the data array as optional from readers that treat 'no pixels' as corruption.
FITS has no unsigned 16-bit type, so unsigned data is stored signed with BZERO = 32768 and recovered as BZERO + BSCALE * stored. Every stored value in this image is negative, so a reader that ignores the scaling returns an entirely negative frame while parsing the file perfectly.
The baseline rung of the BITPIX ladder: a 24x16 synthetic star field stored as unsigned bytes, the one integer width FITS holds without a BZERO shift. Every image in this family carries the same scene so a decoder can be scored across data types.
Single-precision FITS pixels including two NaNs, which is the only way the standard marks undefined data for floating BITPIX, plus one +Inf. Statistics computed without NaN-aware reductions come back as NaN for the entire frame.
The top rung of the BITPIX ladder, carrying the identical synthetic scene as IEEE-754 doubles with DATAMIN and DATAMAX declared. It is the reference against which the 8-, 16- and 32-bit members of the family are scored for precision loss.
A header of 47 cards, so END lands well past the first 2880-byte block, alongside repeated HISTORY and COMMENT cards that legally share a keyword. A parser that reads one block and stops never sees END and truncates the metadata.
A three-HDU FITS file whose primary unit is header-only (NAXIS = 0) with the real data in named SCI and MASK extensions. A reader that only ever looks at HDU 0 reports an empty file, which is exactly the bug this fixture is built to catch.
Every header card of the tangent-plane WCS file transcribed to keyword, value and comment columns. Diff a header parser's output against it to prove the parser split each 80-column card at the right places instead of guessing on whitespace.
A 32-bit integer image carrying a complete tangent-plane WCS: 1-based CRPIX reference pixels, a deliberately negative CDELT1 so right ascension runs the other way, and an ICRS frame. It targets the two mistakes every WCS implementation makes first, the 1-based origin and the flipped axis.
An intentionally corrupt FITS file whose header is complete and whose data unit is cut short, leaving a total length that is not a multiple of the mandatory 2880-byte block. A reader must report the short read rather than hand back a half-filled array padded with whatever it found.
Every value from the CF-1.8 NetCDF grid flattened to one row per cell, with the axis values spelled out in full. Diff a NetCDF-to-table export against this file to prove the reader walked the dimensions in (time, lat, lon) order and did not silently transpose the array.
An intentionally corrupt NetCDF file, cut to its first 512 bytes so the magic number and part of the header survive but the variable table and every data value do not. It is the fixture for the failure path where format detection succeeds and reading must not.
One variable that hides absent data three different ways at once: two _FillValue cells, one legacy missing_value cell and one raw NaN, with valid_min and valid_max also declared. Averaging the raw array without honouring all three gives roughly -60 K instead of a real mean.
The same 4x5x6 temperature grid written in the 64-bit offset variant of NetCDF-3, whose only visible difference from the classic file is the fourth magic byte and the width of the header offsets. Use it to check that format sniffing looks at the version byte instead of stopping at the 'CDF' signature.
A NetCDF-3 classic file holding a 4x5x6 air-temperature field with full CF-1.8 coordinate metadata: standard names, axis attributes, units on every variable, and a declared _FillValue. Use it to check that a reader attaches units and coordinates to the array rather than returning bare numbers.
Four physical quantities on one shared (time, station) grid, each with its own CF units string including the dimensionless '1' and the UDUNITS 'm s-1' spelling. It is the fixture for a unit-aware layer that has to keep four different unit systems straight in a single file.
The same temperature field stored as int16 and recovered through the CF packing attributes scale_factor and add_offset. This is the failure that parses cleanly and is silently wrong: a reader that ignores the attributes returns values around -2000 instead of 260-292 K.
Three CF time coordinates over the same six records: hours from the Unix epoch, days from 2026-01-01, and the same days under a 365_day calendar. A decoder that assumes one epoch, or ignores the calendar attribute, dates the records wrongly without raising anything.
A NetCDF-3 file with a genuine unlimited record dimension, so the record variable is stored interleaved rather than contiguously while the fixed-size station variable is not. It exercises the striding path that a reader written only against fixed dimensions gets wrong.
The stored integer, the unpacked value, the original float and the quantisation error for all 120 cells of the packed NetCDF grid. It makes the cost of int16 packing explicit and gives an unpacking implementation an exact per-cell target.
One array stored twice in the same file: chunked with the shuffle and gzip filters applied, and contiguous with no filters at all. Comparing the two proves a reader ran the HDF5 filter pipeline rather than reading raw chunk bytes.
A compound-dtype dataset mixing an integer key, two float measurements, a fixed-width byte string and a boolean flag in a single record. It is the fixture for readers that must map an HDF5 record type onto a native struct without reordering or repadding the fields.
Eight levels of nested groups, each holding a dataset whose values equal its own depth. Any tree walk that caps recursion depth or flattens names silently loses the lower levels, and the depth-valued arrays make that immediately visible.
Five degenerate but entirely legal datasets — a rank-0 scalar, a zero-length vector, a (0, 5) array, a single-element vector and a NULL dataspace — plus an empty group. None of them is corrupt, and a reader that reports them as errors is the thing being tested.
The CF NetCDF grid expressed with HDF5's own dimension-scale mechanism, so each axis of the 3-D array points at a real coordinate dataset through DIMENSION_LIST references. It lets a reader be tested on scale resolution instead of on filename conventions.
A three-group HDF5 file laid out the way a real bench run is — raw arrays, a processed derivative that names its source in a derived_from attribute, and a metadata group — with units on every dataset. It is the walk-the-tree fixture: a reader has to recurse rather than assume a flat namespace.
One array reachable under four names: itself, a hard link sharing its object address, a soft link resolved at access time, and a soft link pointing nowhere. A walker that counts names instead of object addresses reports four arrays and then crashes on the dangling one.
Twelve datasets, one per numeric HDF5 type, each holding the extreme values of that type including the uint64 and int64 limits that do not survive a trip through a double. It is the fixture that exposes a reader which widens everything to float64 on the way in.
Fixed-width byte strings, variable-length UTF-8 strings and UTF-8 attribute text in one file, including Greek, CJK and combining diacritics. HDF5 hands fixed-width strings back as padded bytes and variable-length ones as decoded text, and conflating the two is where string handling usually breaks.
Four measured quantities where the uncertainty lives in dataset attributes rather than a parallel column, with the coverage factor spelled out so k=1 and k=2 values cannot be confused. It is the fixture for a pipeline that must propagate uncertainty it read from metadata.
An intentionally corrupt HDF5 file cut to 1024 bytes, so the 8-byte signature and superblock survive while the object headers and B-trees they point at do not. Format sniffing will say HDF5 and opening must fail loudly, which is exactly the split this fixture measures.
A MATLAB v7.3 variable store, which is an HDF5 file with a 512-byte MATLAB user block and MATLAB_class attributes — the bytes are the same whichever extension you give it. Because MATLAB is column-major, A appears in HDF5 as its own transpose, which is the conversion bug this fixture is built around.
Every element of the synthetic phantom dataset as tag, value representation, meaning and encoded length, in the ascending tag order the standard mandates. Diff a parser's element list against it to check both the ordering rule and the two different length encodings.
A DICOM Part 10 file built byte by byte: 128-byte preamble, the DICM magic, an explicit-VR file meta group and a 27-element dataset ending in 16-bit pixel data. Every identifier is invented: the patient name is SYNTHETIC^PHANTOM, the instance UIDs sit under the unregistered 2.25 UUID arc, and the pixels are a generated pattern. There is no protected health information here and nothing in the file refers to a real person, device or study.
The same synthetic phantom written with the implicit-VR transfer syntax, where element types never appear on the wire and a reader must consult a data dictionary to know that Rows is a 16-bit integer. The file meta group stays explicit VR, which is the mixed-mode detail parsers most often miss. Every identifier is invented: the patient name is SYNTHETIC^PHANTOM, the instance UIDs sit under the unregistered 2.25 UUID arc, and the pixels are a generated pattern. There is no protected health information here and nothing in the file refers to a real person, device or study.
The identical element stream with the 128-byte preamble and the DICM magic stripped, which is how DICOM often arrives out of a network transfer or a database blob column. It is not a conformant Part 10 file and its content is entirely recoverable, so a reader should fall back rather than reject.
An intentionally corrupt DICOM-shaped file whose header, meta group and every non-pixel element are valid, and whose PixelData element declares a length the file does not contain. A viewer must report the short read rather than render a partial image padded with whatever it found.
An intentionally corrupt Matrix Market file whose banner and size line are perfectly valid and whose entry block stops seven lines short of the declared count. A reader that preallocates from the declared count and never checks ends up with seven silent zeros.
A Hermitian complex matrix where each line carries a real and an imaginary part and the implied mirror entry is the complex conjugate rather than a copy. Every diagonal entry has a zero imaginary part, which the Hermitian property requires and a validator should check.
A 4x3 dense matrix where values run down each column rather than across each row, which is the Matrix Market array convention and the opposite of what most readers assume. Getting it wrong rearranges every element rather than raising an error.
A matrix whose banner declares an integer field, so the values are integers and must not be widened to floats on the way in. The stored range deliberately reaches the signed 16-bit limits, so a narrow integer type overflows visibly.
An 8x8 sparse matrix in Matrix Market coordinate form with twelve stored entries and 1-based indices, the convention that catches every reader written against 0-based arrays. Comment lines beginning with a percent sign appear before the size line, where the format requires them.
A symmetric pattern matrix carrying only positions and only the lower triangle, so nine stored lines describe sixteen non-zeros. Both halves of that — no value column and an implied mirror — are places a reader can silently disagree with the file.
A valid Matrix Market file describing a 6x6 matrix with no stored entries, which is an all-zero matrix rather than an error. It separates readers that model an empty result from readers that treat a missing entry block as truncation.
The twelve stored entries of the sparse matrix with both 1-based and 0-based indices in adjacent columns. It turns the Matrix Market indexing convention from a footnote into something a loader can be diffed against directly.
Five calibration points with the nominal value, the measured value, the signed error and the expanded uncertainty at k=2 with its confidence level stated. It is a synthetic illustration of the layout, not an accredited certificate, and nothing in it refers to a real instrument or laboratory.
Nine laboratory results where only four are plain numbers: two are below the detection limit, one is above range, two are missing in different spellings, and one is a legitimate small negative near the blank. Coercing the censored strings to numbers or to NaN both bias the summary, and the file distinguishes every case explicitly.
Ten weighings as tab-separated values with headers that contain spaces, brackets and parentheses — 'u(mass) [g]' — the way balance software actually writes them. Column names like these break naive slug-based header handling long before the numbers become a problem.
A five-source uncertainty budget laid out the way the GUM prescribes: each source with its distribution, its divisor, its sensitivity coefficient and its contribution, then the combined and expanded values. Rectangular sources are divided by the square root of three, which is the step budget spreadsheets most often get wrong.
Six fictional laboratories reporting the same measurand, scored both by z-score against a fixed sigma and by En number against each lab's own claimed uncertainty. The two statistics disagree about which labs are acceptable, which is the point: En rewards an honest uncertainty claim and z does not.
A 2020-12 JSON Schema for the absorbance rows, carrying the physical unit and coverage factor as custom annotation keywords beside the standard type and range constraints. Annotations like these are ignored by validators and read by humans and tooling, which is precisely the contract being tested.
Eight measurements whose unit symbols use the codepoints that have Unicode look-alikes: MICRO SIGN against GREEK MU, OHM SIGN against GREEK OMEGA, ANGSTROM SIGN against A-with-ring. Each row also carries an ASCII fallback, so a normalisation bug shows up as a column mismatch rather than as an invisible change.
Eight written measurements where the trailing zeros carry the precision of the measurement, alongside what a float parse leaves behind. Parsing 1.200 to the double 1.2 is not a rounding error, it is the loss of the claim that the value is known to four figures.
A synthetic absorbance scan from 400 to 630 nm with a Gaussian band at 520 nm, carrying its expanded uncertainty at k=2 in a dedicated column and a per-row quality flag. The unit and the coverage factor live in the column names, which is the convention most instrument exports actually use.
A full day of thermocouple readings at 30-minute cadence with a constant type-B standard uncertainty and two rows flagged as recovering. The timestamps are explicit UTC with a Z suffix so a reader has no excuse to guess a timezone.
Four batches of five replicate titrations with the mean, sample standard deviation, standard error and relative standard deviation computed for each. The standard deviation uses the n-1 denominator, which is stated explicitly because a population-denominator implementation disagrees on every row.
The same instrument export with units on a second header row instead of inside the column names, which is how a great many laboratory instruments write CSV. An importer that treats row two as data types every measurement column as text and then quietly refuses to plot anything.
Eight arithmetic expressions where binary floating point and exact decimal disagree, with both answers and the signed error side by side. Adding one cent a hundred times does not give one, and this file says by exactly how much.
Five computations done twice, once with the obvious formula and once with the numerically stable one, with the relative error of the naive version alongside. The one-pass variance row is the memorable one: five values a millisecond apart near 1e8 can produce a negative variance.
A ten-step ladder from the smallest representable double up across the subnormal boundary into normal range, showing precision degrading to a single significant bit. Any pipeline running with flush-to-zero enabled turns the first eight entries into plain zeros without reporting anything.
Each rung of the subnormal ladder with its bit pattern, decimal value, C99 hex float and remaining significant bits, plus the value a flush-to-zero pipeline would produce instead. It makes gradual underflow a table you can diff rather than a behaviour you have to infer.
The precision-loss cases as a two-column float64 array holding the original value beside its float32 round trip, both kept at double width so the difference itself is representable. Subtracting the columns gives the error directly without a second narrowing step.
Twelve doubles narrowed to single precision with the absolute, relative and ULP error of each, plus whether the value survived unchanged. It covers the three distinct ways narrowing fails: rounding, overflow to infinity at 1e39, and demotion to a subnormal at 1e-40.
The same 1002 numbers added five different ways, giving results from 0 to 1000 for an exact answer of 1000. Floating-point addition is not associative, and this file is the smallest complete demonstration of what that costs a naive accumulator.
The float32 boundary values split into sign, 8-bit exponent and 23-bit mantissa alongside their decimal forms. Use it to check a single-precision encoder field by field rather than guessing which end of the number went wrong.
The single-precision counterpart of the float64 boundary array, including the 2^24 integer limit where consecutive whole numbers stop being representable. Widening float32 to float64 and back must preserve every one of these bit patterns.
Every value in the float64 boundary array decomposed into its shortest decimal representation, its C99 hexadecimal float form, and its raw sign, exponent and mantissa fields. It turns 'the numbers came back wrong' into a diff you can point at a single bit.
The same boundary values as strict RFC 8259 JSON, where non-finite numbers are null in the numeric field and text in the string field because the standard has no NaN or Infinity literal. It is the fixture for the encoder that emits bare NaN and produces JSON nothing else will parse.
The sixteen structurally distinct float64 values a numeric pipeline has to survive, in binary form: both zeros, both subnormal limits, the smallest normal, epsilon, the largest finite value, both infinities, a quiet NaN and the 2^53 integer boundary. Round-tripping this array is the minimum bar for any float64 codec.
Six large integers written both as JSON numbers and as strings, including the 2^53 boundary where consecutive integers stop being distinguishable in a double. A parser backed by doubles turns 9007199254740993 into 9007199254740992 and reports no error at all.
The six NaN bit patterns broken into sign bit, quiet bit and payload so the difference between a quiet and a signalling NaN is a column rather than folklore. It is the reference for testing whether a serializer preserves NaN payloads or normalises them all to one canonical pattern.
Six distinct NaN bit patterns — quiet, signalling, signed and payload-carrying — stored as float64. They are all NaN and none equals another, so any code that deduplicates, sorts or hashes them by value is doing something undefined and this array proves it.
The same sixteen doubles written in network byte order, so every eight-byte group is the mirror of the little-endian twin. Decoding it with the wrong assumption produces small plausible-looking numbers rather than an error, which is why this pair exists.
Sixteen doubles as a bare 128-byte block with no header, so byte order is knowledge the reader has to bring rather than something the file declares. It is one half of an endian pair that only a correct assumption tells apart.
Every value in the raw endian pair with its exact byte sequence in both orders, so a decoder can be checked offset by offset instead of value by value. Negative zero and the subnormal entries are the rows where a byte-order mistake stops looking like a mistake.
Twelve doubles printed at 15, 16 and 17 significant digits alongside their shortest round-tripping form, with a column recording which precisions actually recover the original bits. Fifteen digits is the default in a lot of formatting code and it loses values, which this table demonstrates rather than asserts.
Nine ways of writing zero, what each parses to, and what dividing one by the result gives. Negative zero compares equal to positive zero yet behaves differently in division and in sign propagation, so a formatter that drops the sign changes results without changing any comparison.
CSV reference listing the four expected HDF5 datasets with shapes and units for lightweight converter assertions. Stable P8 artifact p8-convert-hdf5-summary-csv.
Valid HDF5 hierarchy source with raw, processed, and metadata groups plus four unit-tagged datasets for Convert v2. Stable P8 artifact p8-convert-hdf5-source.
JSON decoded-result reference for the HDF5 hierarchy and its normalisation invariant, kept beside the binary source for semantic rather than byte-level comparison. Stable P8 artifact p8-convert-hdf5-expected.
JSON Schema reference that validates the HDF5 decoded-result contract, kept beside the binary source for semantic rather than byte-level comparison. Stable P8 artifact p8-convert-hdf5-schema.
MDL molfiles and SDfiles, XYZ, SMILES, CIF, and PDB on the chemistry side; FASTA, FASTQ, SAM, BED, GFF3, and Newick trees on the bioinformatics side.
No. Every molecule, sequence, structure, and measurement is generated from a fixed seed and documented in the spec table — no real organism, patient, sample, or observation is described.
NetCDF, HDF5, and FITS fixtures ship with a documented variable/header listing and, where useful, a CSV twin carrying the same values in readable form.
We use Google Analytics and show ads via Adsterra. Non-essential cookies and ad scripts run only after you allow the matching categories. See our cookie policy.
