Average compression times over measured columns

Compute Compress and Decompress ns/point independently for each measured column, then use an equal-column arithmetic mean across the selected datasets. Preserve compression rates, sizes, configurations, and dataset coverage. Keep aggregate-only historical timings unavailable. Update leaderboard scores, ranks, metric labels, charts, details, and CSV exports.

README.md

@@ -6,7 +6,7 @@ colorTo: gray
 sdk: static
 app_file: index.html
 pinned: false
-short_description: Compression rates and encoding/decoding costs
+short_description: Compression rates and compress/decompress costs
 ---
 
 # THULab Time Series Compression Benchmark
@@ -24,6 +24,8 @@ python3 deploy/huggingface-compressionbenchmark/export_results.py
 python3 deploy/huggingface-compressionbenchmark/apply_dataset_scope.py
 # Reapply verified measurement updates before packing the browser payload.
 python3 scripts/integrate_dbp_leaderboard.py --measurements /path/to/frozen-measurements.json --expected-sha256 VERIFIED_SHA256 --receipt /path/to/integration-receipt.json
+# Verify the published source identities and rebuild equal-column timing means.
+python3 scripts/update_site_column_means.py --receipt /path/to/column-mean-receipt.json
 python3 deploy/huggingface-compressionbenchmark/build_ui_payload.py
 ```
 
@@ -35,7 +37,7 @@ Only measurements in the authoritative current project scope are exported. Missi
 
 - Overall and per-dataset leaderboards with runtime, data-type, precision, family, and method filters
 - Sortable metrics, optional columns, and CSV download of the selected ranking
-- Compression rate versus encoding/decoding cost plots
+- Compression rate versus compression/decompression cost plots
 - Dataset-level method details, snapshot provenance, and metric definitions
 - Searchable 169-dataset catalog grouped into six source categories, with explicit measurement availability and source links
 - Overall composite score and average dataset Rank, with 66 valid non-negative one-decimal weight combinations, including zero weights
@@ -43,8 +45,8 @@ Only measurements in the authoritative current project scope are exported. Missi
 
 The summary dataset count and Dataset coverage denominator use the same measured dataset set for the selected runtime, data type, and dataset selection; the default Overall view has 164 measured datasets. All 169 catalog entries remain searchable and selectable in the dataset browser. Dataset coverage can differ by method and runtime; unavailable combinations show **No published measurements**, remain excluded from rankings, and are never converted to zero-valued results. The default family view selects the best measured compression-rate configuration independently for each measured dataset. Switch to **Exact configuration** to hold a configuration fixed. Runtime results stay separate.
 
-The Overall score is `a × average rate + b × normalized average encode time + c × normalized average decode time`. Time normalization is linear min–max across all eligible rows in the selected runtime, scope and row mode; an equal-time range normalizes to zero. Search, family and coverage filters only hide rows and never change the reference. Average Rank averages per-dataset composite-score ranks with dataset-local time normalization and fractional ties. Missing results are omitted. Coverage and candidate counts can differ across datasets; method details expose dataset scores, ranks and candidate counts. CSV downloads include weights, normalization bounds and rank coverage. The default weights are `a=0.4, b=0.3, c=0.3`.
+The Overall score is `a × average rate + b × normalized average compression time + c × normalized average decompression time`. Time normalization is linear min–max across all eligible rows in the selected runtime, scope and row mode; an equal-time range normalizes to zero. Search, family and coverage filters only hide rows and never change the reference. Average Rank averages per-dataset composite-score ranks with dataset-local time normalization and fractional ties. Missing results are omitted. Coverage and candidate counts can differ across datasets; method details expose dataset scores, ranks and candidate counts. CSV downloads include weights, normalization bounds and rank coverage. The default weights are `a=0.4, b=0.3, c=0.3`.
 
-Encoding and decoding costs use each result's recorded point-count contract. Native-float measurements divide by valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Timing comparisons should therefore stay within the same runtime and measurement contract.
+Compression and decompression costs are calculated independently for each usable numeric column as ns/point, then reported as the arithmetic mean across those columns; each column contributes equally. Overall timing pools all measured columns across the selected datasets. If any selected dataset/configuration lacks column-level timing evidence, that Overall timing is unavailable. Historical aggregate-only timing rows without recoverable per-column evidence remain unavailable and are never treated as one synthetic column. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Timing comparisons should therefore stay within the same runtime and measurement contract.
 
 Source project: https://github.com/xjz17/web_compression

app.js

@@ -3,6 +3,10 @@ const $ = (id) => document.getElementById(id);
 const escape = (value) => String(value ?? '').replace(/[&<>"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
 const number = (v) => v != null && Number.isFinite(Number(v)) ? Number(v) : null;
 const mean = (values) => { const a = values.map(number).filter((n) => n !== null); return a.length ? a.reduce((s,n) => s+n,0)/a.length : null; };
+function columnMean(input,key) {
+  if(!input.length||input.some(r=>number(r[key])===null||!Number.isInteger(r.timing_column_count)||r.timing_column_count<=0))return null;
+  return input.reduce((sum,r)=>sum+r[key]*r.timing_column_count,0)/input.reduce((sum,r)=>sum+r.timing_column_count,0);
+}
 const fmt = (v, digits=3) => number(v) === null ? 'Not reported' : Number(v).toLocaleString('en-US',{maximumFractionDigits:digits,minimumFractionDigits:digits});
 const countFmt = (v) => Number(v).toLocaleString('en-US');
 const runtimeName = (v) => ({cpp:'C++',java:'Java',python:'Python'}[v] || v);
@@ -12,10 +16,11 @@ const cols = [
   {key:'composite_score',label:'Composite score ↓',digits:4,visible:true,overallOnly:true},
   {key:'compression_rate',label:'Average rate ↓',digits:4,visible:true},
   {key:'overall_rate',label:'Overall rate ↓',digits:4,visible:false},
-  {key:'compression_time',label:'Encode ns/point ↓',digits:2,visible:true},
-  {key:'decompression_time',label:'Decode ns/point ↓',digits:2,visible:true},
-  {key:'normalized_compression_time',label:'Normalized encode ↓',digits:4,visible:false,overallOnly:true},
-  {key:'normalized_decompression_time',label:'Normalized decode ↓',digits:4,visible:false,overallOnly:true},
+  {key:'compression_time',label:'Compress ns/point ↓',digits:2,visible:true},
+  {key:'decompression_time',label:'Decompress ns/point ↓',digits:2,visible:true},
+  {key:'normalized_compression_time',label:'Normalized compress ↓',digits:4,visible:false,overallOnly:true},
+  {key:'normalized_decompression_time',label:'Normalized decompress ↓',digits:4,visible:false,overallOnly:true},
+  {key:'timing_column_count',label:'Measured columns',digits:0,visible:false},
   {key:'compressed_bytes',label:'Compressed bytes',digits:0,visible:false},
   {key:'original_bytes',label:'Original bytes',digits:0,visible:false},
 ];
@@ -50,7 +55,7 @@ function aggregate(input) {
   for(const [method,source] of groups) {
     const hasBytes=source.every(r=>r.original_bytes!==null && r.original_bytes>0 && r.compressed_bytes!==null && r.compressed_bytes>0);
     const original=hasBytes?source.reduce((s,r)=>s+r.original_bytes,0):null, compressed=hasBytes?source.reduce((s,r)=>s+r.compressed_bytes,0):null;
-    rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:mean(source.map(r=>r.compression_time)),decompression_time:mean(source.map(r=>r.decompression_time)),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source});
+    rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:columnMean(source,'compression_time'),decompression_time:columnMean(source,'decompression_time'),timing_column_count:source.reduce((sum,r)=>sum+r.timing_column_count,0),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source});
   }
   const s=state();
   return addRankingMetrics(rows,parseWeights($('weights').value)).filter(r=>(s.family==='all'||r.family===s.family)&&(!s.search||(s.mode==='family'?r.family:`${r.method} ${r.family}`).toLowerCase().includes(s.search))&&(!s.complete||r.coverage===totalDatasets)).sort((a,b)=>{
@@ -64,7 +69,7 @@ function renderTable() {
   const visible=cols.filter(c=>c.visible&&(!c.overallOnly||activeTab==='overall'));
   $('leaderboard').querySelector('thead').innerHTML=`<tr><th>Position</th><th>Method / configuration</th>${visible.map(c=>`<th aria-sort="${sort.key===c.key?(sort.direction===1?'ascending':'descending'):'none'}"><button data-sort="${c.key}" title="Sort ${escape(c.label)}">${escape(c.label)}${sort.key===c.key?(sort.direction===1?' ▴':' ▾'):''}</button></th>`).join('')}<th>Dataset coverage</th></tr>`;
   const minima=Object.fromEntries(visible.map(c=>[c.key,Math.min(...currentRows.map(r=>number(r[c.key])).filter(n=>n!==null))]));
-  $('leaderboard').querySelector('tbody').innerHTML=currentRows.length?currentRows.map((r,i)=>`<tr><td class="rank numeric">${i+1}</td><td><button class="method-button" data-method="${escape(r.method)}">${escape(r.method)}</button><span class="method-family">${escape(r.family)} · ${escape(runtimeName(r.runtime))}</span></td>${visible.map(c=>`<td class="numeric ${!['compressed_bytes','original_bytes','rank_coverage'].includes(c.key)&&number(r[c.key])!==null&&r[c.key]===minima[c.key]?'best':''}">${c.key==='rank_coverage'?`${r.rank_coverage} / ${r.totalDatasets}`:fmt(r[c.key],c.digits)}</td>`).join('')}<td><span class="coverage ${r.coverage===r.totalDatasets?'full':''}">${r.coverage} / ${r.totalDatasets}</span></td></tr>`).join(''):`<tr><td colspan="${visible.length+3}" class="empty-cell">No measurements match this selection. Try another runtime, data type, or dataset.</td></tr>`;
+  $('leaderboard').querySelector('tbody').innerHTML=currentRows.length?currentRows.map((r,i)=>`<tr><td class="rank numeric">${i+1}</td><td><button class="method-button" data-method="${escape(r.method)}">${escape(r.method)}</button><span class="method-family">${escape(r.family)} · ${escape(runtimeName(r.runtime))}</span></td>${visible.map(c=>`<td class="numeric ${!['compressed_bytes','original_bytes','rank_coverage','timing_column_count'].includes(c.key)&&number(r[c.key])!==null&&r[c.key]===minima[c.key]?'best':''}">${c.key==='rank_coverage'?`${r.rank_coverage} / ${r.totalDatasets}`:fmt(r[c.key],c.digits)}</td>`).join('')}<td><span class="coverage ${r.coverage===r.totalDatasets?'full':''}">${r.coverage} / ${r.totalDatasets}</span></td></tr>`).join(''):`<tr><td colspan="${visible.length+3}" class="empty-cell">No measurements match this selection. Try another runtime, data type, or dataset.</td></tr>`;
   for(const button of $('leaderboard').querySelectorAll('[data-sort]'))button.addEventListener('click',()=>{const key=button.dataset.sort;sort={key,direction:sort.key===key?-sort.direction:1};refresh();});
   for(const button of $('leaderboard').querySelectorAll('[data-method]'))button.addEventListener('click',()=>showMethod(button.dataset.method,true));
   $('row-count').textContent=`${currentRows.length} ${state().mode==='family'?'method families':'method configurations'} · sorted by ${cols.find(c=>c.key===sort.key)?.label??sort.key}`;
@@ -73,7 +78,7 @@ function renderTable() {
 function refresh() {
   if(!snapshot)return;
   $('precision').disabled=$('dtype').value!=='float';
-  const selectedDataset=state().dataset,selectedHasMeasurements=selectedDataset==='all'||records.some(r=>r.dataset===selectedDataset),columnCoverageNote='Metrics aggregate the numeric columns measured for each method; column coverage may differ.';
+  const selectedDataset=state().dataset,selectedHasMeasurements=selectedDataset==='all'||records.some(r=>r.dataset===selectedDataset),columnCoverageNote='Compress and Decompress times are arithmetic means of each measured column’s ns/point; every column has equal weight. Column coverage may differ by method. Historical aggregate-only timings are not reported as column means.';
   if(!selectedHasMeasurements) {
     $('results-note').textContent=`No published measurements are available for this catalog dataset. It is excluded from rankings rather than treated as zero. ${columnCoverageNote}`;
   } else if(scopeKey()==='float'&&!records.some(r=>r.scope==='float')) {
@@ -83,7 +88,7 @@ function refresh() {
   } else $('results-note').textContent=`${state().mode==='family'?'Each family uses its lowest-rate measured configuration per dataset. Configurations may differ across datasets; use Exact configuration for fixed parameters.':'Each row retains one exact configuration. Lower compression rates and lower ns/point are better. Coverage counts datasets, not identical column sets.'} ${columnCoverageNote}`;
   currentRows=aggregate(filteredRecords(true));
   const weights=parseWeights($('weights').value);
-  $('score-note').textContent=`Score = ${weights[0].toFixed(1)} × average rate + ${weights[1].toFixed(1)} × normalized encode + ${weights[2].toFixed(1)} × normalized decode. Lower is better. Time normalization: (time − minimum) / (maximum − minimum), across all measured rows in this runtime, scope and row mode. Search and visibility filters keep the reference fixed. Average Rank: mean of per-dataset score ranks with dataset-local time normalization; ties share their average position. Missing results are omitted. Dataset candidate counts differ, so compare rank coverage and inspect method details.`;
+  $('score-note').textContent=`Score = ${weights[0].toFixed(1)} × average rate + ${weights[1].toFixed(1)} × normalized compress + ${weights[2].toFixed(1)} × normalized decompress. Lower is better. Time normalization: (time − minimum) / (maximum − minimum), across all measured rows in this runtime, scope and row mode. Search and visibility filters keep the reference fixed. Average Rank: mean of per-dataset score ranks with dataset-local time normalization; ties share their average position. Missing results are omitted. Dataset candidate counts differ, so compare rank coverage and inspect method details.`;
   const s=state(),scope=scopeKey(),measuredCount=coverageDatasetCount(),ds=s.dataset==='all'?`all ${measuredCount} measured datasets`:datasetDisplayName(s.dataset);
   $('dataset-count').textContent=countFmt(measuredCount);$('dataset-count-label').textContent='measured datasets';
   const names={overall:'available numeric measurements',integer:'integer columns',float:'floating-point columns',fixed_float:'fixed-precision float columns',nonfixed_float:'non-fixed-precision float columns'};
@@ -110,7 +115,7 @@ function showMethod(method,focus=false) {
   if(!row){selectedMethod=null;detail.hidden=true;return;}selectedMethod=method;
   const meta=methods.get(method)??methods.get(row.source[0].configuration), pipeline=meta?.operator_pipeline;
   const source=row.source.slice().sort((a,b)=>a.dataset.localeCompare(b.dataset));
-  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>encoding ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>decoding ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Dataset metrics below come from the published result files. Measurement boundaries, source hashes, and available verification evidence are recorded in the manifest.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Encode ns/point ↓</th><th>Decode ns/point ↓</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,2)}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
+  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>Compress ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>Decompress ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Dataset metrics below come from the published result files. Measurement boundaries, source hashes, and available verification evidence are recorded in the manifest.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,2)}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
   detail.hidden=false;$('close-detail').addEventListener('click',()=>{detail.hidden=true;selectedMethod=null;});
   if(focus){detail.scrollIntoView({block:'nearest',behavior:'auto'});detail.focus({preventScroll:true});}
 }
@@ -125,16 +130,16 @@ function renderChart() {
   let graph='';
   for(let i=0;i<=5;i++){const rate=maxRate*i/5,px=x(rate);graph+=`<line class="gridline" x1="${px}" y1="${pad.top}" x2="${px}" y2="${height-pad.bottom}"/><text class="axis-label" x="${px}" y="${height-pad.bottom+25}" text-anchor="middle">${fmt(rate,2)}</text>`;}
   for(let i=minLog;i<=maxLog;i++){const n=10**i,py=y(n);graph+=`<line class="gridline" x1="${pad.left}" y1="${py}" x2="${width-pad.right}" y2="${py}"/><text class="axis-label" x="${pad.left-12}" y="${py+4}" text-anchor="end">${n.toLocaleString('en-US',{maximumFractionDigits:3})}</text>`;}
-  for(const r of valid)graph+=`<circle class="point" tabindex="0" role="button" aria-label="${escape(r.method)}: compression rate ${fmt(r.compression_rate,4)}, ${metric==='compression_time'?'encoding':'decoding'} ${fmt(r[metric],2)} ns per point" data-method="${escape(r.method)}" cx="${x(r.compression_rate)}" cy="${y(r[metric])}" r="6"><title>${escape(r.method)} | rate ${fmt(r.compression_rate,4)} | ${fmt(r[metric],2)} ns/point | coverage ${r.coverage}/${r.totalDatasets}</title></circle>`;
-  graph+=`<text class="axis-label" x="${width/2}" y="${height-13}" text-anchor="middle">Average compression rate (compressed / original) ↓</text><text class="axis-label" transform="translate(20 ${height/2}) rotate(-90)" text-anchor="middle">${metric==='compression_time'?'Encoding':'Decoding'} ns/point (log scale) ↓</text>`;
-  $('chart').innerHTML=`<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Measured compression rates versus ${metric==='compression_time'?'encoding':'decoding'} cost">${graph}</svg>`;
+  for(const r of valid)graph+=`<circle class="point" tabindex="0" role="button" aria-label="${escape(r.method)}: compression rate ${fmt(r.compression_rate,4)}, ${metric==='compression_time'?'compression':'decompression'} ${fmt(r[metric],2)} ns per point" data-method="${escape(r.method)}" cx="${x(r.compression_rate)}" cy="${y(r[metric])}" r="6"><title>${escape(r.method)} | rate ${fmt(r.compression_rate,4)} | ${fmt(r[metric],2)} ns/point | coverage ${r.coverage}/${r.totalDatasets}</title></circle>`;
+  graph+=`<text class="axis-label" x="${width/2}" y="${height-13}" text-anchor="middle">Average compression rate (compressed / original) ↓</text><text class="axis-label" transform="translate(20 ${height/2}) rotate(-90)" text-anchor="middle">${metric==='compression_time'?'Compress':'Decompress'} ns/point (log scale) ↓</text>`;
+  $('chart').innerHTML=`<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Measured compression rates versus ${metric==='compression_time'?'compression':'decompression'} cost">${graph}</svg>`;
   for(const p of $('chart').querySelectorAll('[data-method]')){p.addEventListener('click',()=>showMethod(p.dataset.method,true));p.addEventListener('keydown',e=>{if(e.key==='Enter'||e.key===' '){e.preventDefault();showMethod(p.dataset.method,true);}});}
 }
 function csv() {
   const quote=v=>{let text=String(v??'');if(typeof v==='string'&&/^[=+@-]/.test(text))text="'"+text;return `"${text.replace(/"/g,'""')}"`;};
   const weights=parseWeights($('weights').value);
-  const columns=['position','method','runtime','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','encode_ns_per_point','decode_ns_per_point','weight_a','weight_b','weight_c','normalized_encode','normalized_decode','composite_score','average_rank','rank_dataset_coverage','normalization_reference_rows','encode_min','encode_max','decode_min','decode_max','normalization','rank_definition','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset'];
-  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected runtime/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration])))].map(quote).join(','));
+  const columns=['position','method','runtime','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','compress_ns_per_point','decompress_ns_per_point','weight_a','weight_b','weight_c','normalized_compress','normalized_decompress','composite_score','average_rank','rank_dataset_coverage','normalization_reference_rows','compress_min','compress_max','decompress_min','decompress_max','normalization','rank_definition','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset','timing_column_count','timing_aggregation'];
+  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected runtime/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration]))),r.timing_column_count,'arithmetic mean of per-column ns/point; equal weight per measured column'].map(quote).join(','));
   const url=URL.createObjectURL(new Blob(['\ufeff'+[columns.join(','),...body].join('\r\n')],{type:'text/csv;charset=utf-8'}));const a=document.createElement('a');a.href=url;a.download=`THULab-compression-${state().runtime}-${scopeKey()}-${state().dataset}.csv`;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);
 }
 function safeHttpUrl(value) {
@@ -276,7 +281,7 @@ function renderAbout() {
   $('provenance').innerHTML=`<table class="provenance-table"><tbody>${Object.entries(info).map(([k,v])=>`<tr><th>${escape(k)}</th><td class="source-code">${escape(v)}</td></tr>`).join('')}</tbody></table>${exclusions.length?`<h3>Excluded or unavailable results</h3><p class="source-code">${escape(typeof exclusions==='string'?exclusions:JSON.stringify(exclusions))}</p>`:''}`;
 }
 function init() {
-  if(snapshot.compact_records){const t=snapshot.record_tables;snapshot.dataset_results=snapshot.compact_records.map(r=>({dataset:t.datasets[r[0]],scope:t.scopes[r[1]],runtime:t.runtimes[r[2]],family:t.families[r[3]],method:t.configurations[r[4]],algorithm_variant:t.configurations[r[4]],compression_rate:r[5],compression_time_ns_per_point:r[6],decompression_time_ns_per_point:r[7],original_size_bytes:r[8],compressed_size_bytes:r[9]}));delete snapshot.compact_records;}
+  if(snapshot.compact_records){const t=snapshot.record_tables;snapshot.dataset_results=snapshot.compact_records.map(r=>({dataset:t.datasets[r[0]],scope:t.scopes[r[1]],runtime:t.runtimes[r[2]],family:t.families[r[3]],method:t.configurations[r[4]],algorithm_variant:t.configurations[r[4]],compression_rate:r[5],compression_time_ns_per_point:r[6],decompression_time_ns_per_point:r[7],original_size_bytes:r[8],compressed_size_bytes:r[9],timing_column_count:r[10]}));delete snapshot.compact_records;}
   for(const m of snapshot.methods||[]) { const method=typeof m==='string'?{name:m}:m;methods.set(method.name??method.method,method);for(const c of method.configurations||[])methods.set(c.algorithm_variant,{...method,name:c.algorithm_variant,family:method.name}); }
   for(const d of snapshot.datasets||[])datasets.set(d.key??d.dataset,d);
   records=(snapshot.dataset_results||snapshot.records||[]).map(normalizeRecord).filter(r=>r.method&&r.dataset&&r.compression_rate>0);
@@ -308,5 +313,5 @@ function setupTheme() {
 setupTheme();
 void loadReferenceCatalog();
 void loadDatasetCatalog();
-try { const response=await fetch('./ui-data.json?v=20261009-dbp-integrated-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
+try { const response=await fetch('./ui-data.json?v=20261009-column-mean-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
 catch(e){$('load-error').hidden=false;$('load-error').textContent=`The result snapshot could not be loaded. Please reload the page or download the JSON from the repository. ${e.message}`;$('snapshot').textContent='Snapshot unavailable';$('leaderboard').querySelector('tbody').innerHTML='<tr><td class="empty-cell">Results unavailable.</td></tr>';}

apply_dataset_scope.py

@@ -47,9 +47,10 @@ def apply() -> None:
         r = dict(original)
         # Preserve the exporter's 8-byte-equivalent denominator, including
         # historical rows whose source byte totals are not divisible by eight.
-        r["point_count"] = r["original_size_bytes"] / 8.0
-        r["compression_time_ns"] = r["compression_time_ns_per_point"] * r["point_count"]
-        r["decompression_time_ns"] = r["decompression_time_ns_per_point"] * r["point_count"]
+        r.setdefault("point_count", r["original_size_bytes"] / 8.0)
+        # A per-column arithmetic mean cannot be expanded back into elapsed
+        # time from a dataset point total. Leave weighted elapsed-time metrics
+        # unavailable unless the source row still carries the original totals.
         configurations[r["runtime"], r["scope"], r["family"], r["method"]].append(r)
         if r["is_best_rate_in_family"]:
             families[r["runtime"], r["scope"], r["family"]].append(r)

build_ui_payload.py

@@ -20,7 +20,7 @@ def build() -> None:
         compact.append([*(indices[key][r[field]] for key,field in fields.items()),
                         r['compression_rate'], r['compression_time_ns_per_point'],
                         r['decompression_time_ns_per_point'], r['original_size_bytes'],
-                        r['compressed_size_bytes']])
+                        r['compressed_size_bytes'], r.get('timing_column_count', 0)])
     payload = {key: data[key] for key in ('schema_version','benchmark','coverage','datasets','methods','scopes','source')}
     if 'dataset_summary' in data:
         payload['dataset_summary'] = data['dataset_summary']

data.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:605712c81fe1189cbfb804e52a680c17c55570ac4dfaa296cdd7e2c747ece9c9
-size 35484449
+oid sha256:099f735c91c5ef4dff2b15ea2851caa6edd16f304f0063bfe6de948f475b4ba7
+size 37791099

export_results.py

@@ -158,12 +158,27 @@ def _configuration_rows(
     )
 
     bundle_dir = BACKEND_DIR / "dataset" / dataset_key
-    report = read_benchmark_report(
-        bundle_dir,
-        dataset_key,
-        data_type=scope["data_type"],
-        implement_language=runtime,
-    )
+    if scope["data_type"] == "overall":
+        report_parts = []
+        for report_type in ("int", "float"):
+            part = read_benchmark_report(
+                bundle_dir, dataset_key, data_type=report_type, implement_language=runtime
+            )
+            if part is not None and not part.empty:
+                part = part.copy()
+                part["_timing_source_type"] = report_type
+                report_parts.append(part)
+        report = pd.concat(report_parts, ignore_index=True) if report_parts else None
+    else:
+        report = read_benchmark_report(
+            bundle_dir,
+            dataset_key,
+            data_type=scope["data_type"],
+            implement_language=runtime,
+        )
+        if report is not None and not report.empty:
+            report = report.copy()
+            report["_timing_source_type"] = scope["data_type"]
     if report is None or report.empty:
         return []
     if scope["data_type"] == "float":
@@ -217,8 +232,32 @@ def _configuration_rows(
         original_bytes = _finite(record.originalSize, positive=True)
         compressed_bytes = _finite(record.compressedSize, positive=True)
         points = original_bytes / 8.0
-        compression_time_ns = _finite(record.compressionTime)
-        decompression_time_ns = _finite(record.decompressionTime)
+        timing_rows = work[
+            (work["algorithm"].astype(str) == str(record.algorithm))
+            & (pd.to_numeric(work["column_index"], errors="coerce") >= 0)
+        ].copy()
+        timing_column_count = len(timing_rows)
+        if timing_column_count:
+            timing_columns = timing_rows.groupby(
+                ["_timing_source_type", "column_index"], as_index=False
+            ).agg(
+                originalSize=("originalSize", "sum"),
+                compressionTime=("compressionTime", "sum"),
+                decompressionTime=("decompressionTime", "sum"),
+            )
+            timing_column_count = len(timing_columns)
+            timing_points = timing_columns["originalSize"] / 8.0
+            compression_time_ns_per_point = float(
+                (timing_columns["compressionTime"] / timing_points).mean()
+            )
+            decompression_time_ns_per_point = float(
+                (timing_columns["decompressionTime"] / timing_points).mean()
+            )
+        else:
+            # A column_index=-1 row is a whole-report aggregate. It cannot prove
+            # the requested arithmetic mean of individual column timings.
+            compression_time_ns_per_point = None
+            decompression_time_ns_per_point = None
         rows.append(
             {
                 "dataset": dataset_key,
@@ -231,11 +270,12 @@ def _configuration_rows(
                 "original_size_bytes": int(round(original_bytes)),
                 "compressed_size_bytes": int(round(compressed_bytes)),
                 "point_count": int(round(points)),
-                "compression_time_ns": compression_time_ns,
-                "decompression_time_ns": decompression_time_ns,
+                "compression_time_ns": _finite(record.compressionTime),
+                "decompression_time_ns": _finite(record.decompressionTime),
                 "compression_rate": compressed_bytes / original_bytes,
-                "compression_time_ns_per_point": compression_time_ns / points,
-                "decompression_time_ns_per_point": decompression_time_ns / points,
+                "compression_time_ns_per_point": compression_time_ns_per_point,
+                "decompression_time_ns_per_point": decompression_time_ns_per_point,
+                "timing_column_count": timing_column_count,
             }
         )
     return sorted(rows, key=lambda row: (row["method"], row["algorithm_variant"]))
@@ -308,8 +348,33 @@ def _aggregate_rows(
     original_sum = sum(row["original_size_bytes"] for row in rows)
     compressed_sum = sum(row["compressed_size_bytes"] for row in rows)
     point_sum = sum(row["point_count"] for row in rows)
-    comp_time_sum = sum(row["compression_time_ns"] for row in rows)
-    decomp_time_sum = sum(row["decompression_time_ns"] for row in rows)
+    elapsed_rows = [
+        row for row in rows
+        if row.get("point_count", 0) > 0
+        and row.get("compression_time_ns") is not None
+        and row.get("decompression_time_ns") is not None
+    ]
+    elapsed_point_sum = sum(row["point_count"] for row in elapsed_rows)
+    comp_time_sum = sum(row["compression_time_ns"] for row in elapsed_rows)
+    decomp_time_sum = sum(row["decompression_time_ns"] for row in elapsed_rows)
+    timing_rows = [
+        row for row in rows
+        if row.get("timing_column_count", 0) > 0
+        and row.get("compression_time_ns_per_point") is not None
+        and row.get("decompression_time_ns_per_point") is not None
+    ]
+    timing_column_count = sum(row["timing_column_count"] for row in timing_rows)
+    timing_complete = len(timing_rows) == len(rows)
+    average_compression_time = (
+        sum(row["compression_time_ns_per_point"] * row["timing_column_count"] for row in timing_rows)
+        / timing_column_count
+        if timing_column_count and timing_complete else None
+    )
+    average_decompression_time = (
+        sum(row["decompression_time_ns_per_point"] * row["timing_column_count"] for row in timing_rows)
+        / timing_column_count
+        if timing_column_count and timing_complete else None
+    )
     return {
         "runtime": runtime,
         "scope": scope_key,
@@ -319,16 +384,15 @@ def _aggregate_rows(
         "dataset_count": len(rows),
         "overall_compression_rate": compressed_sum / original_sum,
         "average_compression_rate": sum(row["compression_rate"] for row in rows) / len(rows),
-        "weighted_compression_time_ns_per_point": comp_time_sum / point_sum,
-        "average_compression_time_ns_per_point": sum(
-            row["compression_time_ns_per_point"] for row in rows
-        )
-        / len(rows),
-        "weighted_decompression_time_ns_per_point": decomp_time_sum / point_sum,
-        "average_decompression_time_ns_per_point": sum(
-            row["decompression_time_ns_per_point"] for row in rows
-        )
-        / len(rows),
+        "weighted_compression_time_ns_per_point": (
+            comp_time_sum / elapsed_point_sum if elapsed_point_sum else None
+        ),
+        "average_compression_time_ns_per_point": average_compression_time,
+        "weighted_decompression_time_ns_per_point": (
+            decomp_time_sum / elapsed_point_sum if elapsed_point_sum else None
+        ),
+        "average_decompression_time_ns_per_point": average_decompression_time,
+        "timing_column_count": timing_column_count,
         "original_size_bytes": original_sum,
         "compressed_size_bytes": compressed_sum,
         "point_count": point_sum,
@@ -378,13 +442,10 @@ def main() -> int:
                     )
                 )
     configuration_aggregates, family_best_aggregates = _aggregate_current_rows(dataset_rows)
-    # Keep the published per-dataset payload compact. These totals are used above
-    # to produce the weighted aggregates; the UI needs the byte totals and
-    # per-point times, not duplicate time totals or the derivable point count.
-    for row in dataset_rows:
-        row.pop("compression_time_ns", None)
-        row.pop("decompression_time_ns", None)
-        row.pop("point_count", None)
+    # Retain the source elapsed-time and point totals. A per-column arithmetic
+    # mean cannot be expanded back into elapsed time from a dataset point total,
+    # so later scope transforms must use these measured totals rather than infer
+    # them from the displayed mean.
 
     families = sorted({row["family"] for row in dataset_rows})
     configurations = sorted(
@@ -466,7 +527,7 @@ def main() -> int:
             "current_result_selection": "visible configurations of methods categorized as lossless-design by the project; result-level float round trips are not established",
             "paper_result_selection": "the separate paper_table3 section contains its frozen 20-method C++ snapshot",
             "scope_note": "Current result rows cover numeric int/float report evidence for the retained 19 public datasets. They reflect the columns present in each report; they do not assert full-column coverage beyond those files.",
-            "aggregation_note": "Average metrics are arithmetic means over available per-dataset measurements. Overall compression rate and weighted times use summed measured bytes, points, and nanoseconds only.",
+            "aggregation_note": "Compression and decompression time averages are arithmetic means of available per-column nanoseconds per point. Dataset rows without column-level timing evidence are unavailable for timing; any aggregate containing one of these rows also has unavailable timing and is excluded from timing-based scores. Overall compression rate and weighted times use summed measured bytes, points, and nanoseconds only.",
             "selection_note": "Configuration views retain measured configurations passing the project's method-name filter. This does not certify every result as lossless. Family views choose the lowest-rate configuration independently for each dataset, scope, and runtime.",
             "notes": [
                 "Missing combinations are unavailable rather than zero.",
@@ -477,7 +538,7 @@ def main() -> int:
                 "compression_rate": "compressed bytes divided by original numeric bytes; lower is better",
                 "average_compression_rate": "arithmetic mean of per-dataset compression rates",
                 "overall_compression_rate": "sum of compressed bytes divided by sum of original numeric bytes",
-                "average_time_ns_per_point": "arithmetic mean of per-dataset nanoseconds per 8-byte numeric point",
+                "average_time_ns_per_point": "arithmetic mean of per-column nanoseconds per numeric point; legacy CSV columns retain their 8-byte-equivalent point denominator",
                 "weighted_time_ns_per_point": "sum of measured nanoseconds divided by sum of 8-byte numeric points",
                 "paper_median_balanced_score": "stored paper snapshot value; normalization is paper-scope specific and lower is better",
             },

index.html

@@ -3,11 +3,11 @@
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width,initial-scale=1">
-  <meta name="description" content="THULab time-series compression benchmark: measured compression rates, encoding and decoding costs, and dataset coverage.">
+  <meta name="description" content="THULab time-series compression benchmark: measured compression rates, compression and decompression costs, and dataset coverage.">
   <meta name="color-scheme" content="light dark">
   <title>THULab | Time Series Compression Benchmark</title>
   <link rel="stylesheet" href="style.css?v=20261009-dbp-integrated-v1">
-  <script src="app.js?v=20261009-coverage-v1" type="module"></script>
+  <script src="app.js?v=20261009-column-mean-v1" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>
@@ -19,7 +19,7 @@
     <section class="intro" aria-labelledby="title">
       <p class="eyebrow">Time-series systems research</p>
       <h1 id="title">Time Series Compression Leaderboard</h1>
-      <p class="intro-text">Compare published storage, encoding, and decoding measurements across time-series datasets.</p>
+      <p class="intro-text">Compare published storage, compression, and decompression measurements across time-series datasets.</p>
       <p class="snapshot" id="snapshot">Loading benchmark snapshot…</p>
     </section>
     <div class="summary-strip" id="summary" aria-label="Snapshot coverage">
@@ -62,9 +62,9 @@
         <div><h2 id="view-title">Overall leaderboard</h2><p id="selection-summary" class="muted" aria-live="polite">Reading published results…</p></div>
         <div class="toolbar-actions"><button id="reset" class="quiet-button">Reset filters</button><button id="download" class="primary-button" disabled>Download CSV</button></div>
       </div>
-      <div class="results-note" id="results-note">Compression rate = compressed bytes / original bytes. Lower rates and lower ns/point are better. Metrics aggregate the numeric columns measured for each method; column coverage may differ.</div>
+      <div class="results-note" id="results-note">Compression rate = compressed bytes / original bytes. Lower rates and lower ns/point are better. Compression and decompression costs are the arithmetic mean of the measured columns' ns/point values; column coverage may differ. Historical aggregate-only timings without per-column evidence are not inferred.</div>
       <div id="score-controls" class="score-controls">
-        <label>Score weights · a: rate / b: encode / c: decode<select id="weights" aria-label="Score weights a b c"></select></label>
+        <label>Score weights · a: rate / b: compress / c: decompress<select id="weights" aria-label="Score weights a b c"></select></label>
         <p id="score-note" class="muted" aria-live="polite">Non-negative weights in steps of 0.1, summing to 1.0.</p>
       </div>
       <div class="table-settings">
@@ -72,7 +72,7 @@
         <details><summary>Display columns</summary><div id="column-options" class="column-options"></div></details>
       </div>
       <div id="chart-view" hidden>
-        <div class="chart-controls"><label>Vertical axis<select id="chart-metric"><option value="compression_time">Encoding cost (ns/point)</option><option value="decompression_time">Decoding cost (ns/point)</option></select></label><span class="muted">Lower and further left is better. Click a point for method details.</span></div>
+        <div class="chart-controls"><label>Vertical axis<select id="chart-metric"><option value="compression_time">Compression cost (ns/point)</option><option value="decompression_time">Decompression cost (ns/point)</option></select></label><span class="muted">Lower and further left is better. Click a point for method details.</span></div>
         <div id="chart" class="chart" aria-label="Compression rate and execution cost scatter plot"></div>
       </div>
       <div id="leaderboard-wrap" class="table-wrap" tabindex="0" aria-label="Scrollable sortable leaderboard">
@@ -108,9 +108,9 @@
       <dl class="definitions">
         <div><dt>Average compression rate ↓</dt><dd>Arithmetic mean of the per-dataset compression rates in the selected scope.</dd></div>
         <div><dt>Overall compression rate ↓</dt><dd>Total compressed bytes divided by total original bytes over the selected measured records.</dd></div>
-        <div><dt>Encoding / decoding cost ↓</dt><dd>Nanoseconds per point under each result's recorded measurement contract. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Compare timings within the same runtime and measurement contract.</dd></div>
+        <div><dt>Compression / decompression cost ↓</dt><dd>For each result with column-level timing evidence, calculate ns/point independently for every usable numeric column, then take the arithmetic mean across those columns. Each column contributes equally. Overall timing pools all measured columns across the selected datasets; if any selected dataset/configuration lacks column-level timing evidence, that timing is Not reported. Historical aggregate-only timing rows without recoverable per-column values are not inferred. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Compare timings within the same runtime and measurement contract.</dd></div>
         <div><dt>Coverage</dt><dd>Datasets with usable measurements for a method out of the measured datasets in the selected runtime, data type, and dataset selection. The summary dataset count uses the same selection. Missing results are never filled with zero.</dd></div>
-        <div><dt>Composite score ↓</dt><dd>a × average compression rate + b × normalized average encoding time + c × normalized average decoding time. Each time uses min–max over all measured rows in the selected runtime, scope and row mode, before search, family and coverage filters. If all times are equal, their normalized value is zero. All measured inputs must have usable timing metrics.</dd></div>
+        <div><dt>Composite score ↓</dt><dd>a × average compression rate + b × normalized average compression time + c × normalized average decompression time. Each time uses min–max over all measured rows in the selected runtime, scope and row mode, before search, family and coverage filters. If all times are equal, their normalized value is zero. All measured inputs must have usable timing metrics.</dd></div>
         <div><dt>Average Rank ↓</dt><dd>Compute the same weighted score within each dataset, normalizing times within that dataset. Rank lower scores first; ties share their average position. Then take the arithmetic mean of the method's available dataset ranks. Weights are non-negative tenths summing to 1.0. Missing measurements do not receive ranks.</dd></div>
       </dl>
       <h3>Reading the rankings</h3>
@@ -121,7 +121,7 @@
       <p><a href="data.json" download>Result snapshot (JSON)</a> · <a href="manifest.json" download>Source manifest (JSON)</a></p>
       <div id="provenance"></div>
       <h3>Contribute a result</h3>
-      <p>Run the project benchmark and provide the codec/configuration, input identity, encoding and decoding measurements, execution environment, and round-trip validation evidence. Results can be updated from the source project using the snapshot exporter included in the Space repository.</p>
+      <p>Run the project benchmark and provide the codec/configuration, input identity, compression and decompression measurements, execution environment, and round-trip validation evidence. Results can be updated from the source project using the snapshot exporter included in the Space repository.</p>
     </section>
     <noscript><p class="error-message">Enable JavaScript to filter and sort this leaderboard. You can also download <a href="data.json">the results JSON</a>.</p></noscript>
     <footer><span>THULab · Time Series Compression Benchmark</span><span id="footer-snapshot"></span></footer>

manifest.json

@@ -25,10 +25,13 @@
       "python"
     ],
     "scope_count": 5,
-    "source_report_file_count": 108
+    "source_report_file_count": 108,
+    "timing_column_mean_dataset_result_count": 64879,
+    "timing_column_observation_count": 1435539,
+    "timing_unavailable_dataset_result_count": 340
   },
   "data_file": "data.json",
-  "data_sha256": "605712c81fe1189cbfb804e52a680c17c55570ac4dfaa296cdd7e2c747ece9c9",
+  "data_sha256": "099f735c91c5ef4dff2b15ea2851caa6edd16f304f0063bfe6de948f475b4ba7",
   "dataset_catalog_sha256": "d69abc85742dc050e4cdab1e5a03fd3392a0e0f1964b2a88ca87ba7f768b7385",
   "excluded_content": [
     "raw datasets",
@@ -762,5 +765,16 @@
       "sha256": "d69abc85742dc050e4cdab1e5a03fd3392a0e0f1964b2a88ca87ba7f768b7385",
       "status": "reviewed_public_catalog"
     }
-  ]
+  ],
+  "timing_recalculation": {
+    "aggregate_only_rows_excluded_from_timing": 340,
+    "dbp_float_audit_path": "analysis_outputs/dbp_float_e2e_20261009/publish_payload/dbp-audit.json",
+    "dbp_float_audit_sha256": "febe0d4494cf3778bb3e386ac8674f24406e29d1d7d9b47bd834b332b0e201fb",
+    "dbp_precision_source_file_count": 376,
+    "dbp_precision_source_hash_status": "all_match",
+    "generated_at": "2026-10-09T06:52:14.348090+00:00",
+    "policy": "arithmetic_mean_of_per_column_ns_per_point",
+    "result_csv_file_count": 108,
+    "result_csv_sha256_status": "all_match"
+  }
 }