43:["$","title",null,{"children":"The Eiffel-proximate Tourist Trap Effect | geo-theo | Observable"}] 4b:T7e34,// Opening copy of Cell 10 — paste into one Observable JavaScript or TypeScript cell. // Attach restaurants_paris.geojson, basemap_paris_AOI.geojson, AOI.geojson, // and eiffel_buffers.geojson before running. All four use EPSG:2154. import * as cell00OpeningPlot from "npm:@observablehq/plot"; import * as cell00OpeningHtl from "npm:htl"; import * as cell00OpeningD3 from "npm:d3"; // EDIT THE TITLE AND SUBTITLE HERE. const cell00OpeningTitle = "The Eiffel-proximate Tourist Trap Effect"; const cell00OpeningSubtitle = "Weighted-Rating Distance Decay"; // Didot is used when available; the remaining fonts are local fallbacks. const cell00OpeningFont = 'Didot, "Bodoni MT", Georgia, serif'; // EDIT THESE COLORS: keys match the basemap's source attribute exactly. const cell00OpeningBasemapColors = { "Parcs": "#F0F4F2", "La Seine": "#F6F8FA", "Tour Eiffel": "#563B22", "batiments": "#F5F5F5" }; const cell00OpeningBackground = "#ffffff"; const cell00OpeningUnknownSourceColor = "#eeeeee"; const cell00OpeningMissingRatingColor = "#929292"; const cell00OpeningVignetteStartMeters = 1500; // Fade starts at the outer buffer. const cell00OpeningVignetteStrength = 1; // White opacity at the farthest map corner, from 0 to 1. const cell00OpeningRingDashLength = 5; const cell00OpeningRingDashGap = 7; const cell00OpeningRingOpacity = 0.67; // 33% transparent. // Both restaurant points and band outlines use this same 1–5 rating scale. const cell00OpeningRatingScale = { type: "linear", domain: [1, 1.5, 2.5, 3.5, 4.5, 5], range: ["#a50026", "#a50026", "#f6a09a", "#a6cee3", "#08306b", "#08306b"], interpolate: "rgb", clamp: true, label: "Restaurant rating / median rating in band" }; const [cell00OpeningRestaurants, cell00OpeningBasemap, cell00OpeningAOI, cell00OpeningBuffers] = await Promise.all([ FileAttachment("restaurants_paris.geojson").json(), FileAttachment("basemap_paris_AOI.geojson").json(), FileAttachment("AOI.geojson").json(), FileAttachment("eiffel_buffers.geojson").json() ]); for (const [name, data] of Object.entries({ restaurants: cell00OpeningRestaurants, basemap: cell00OpeningBasemap, AOI: cell00OpeningAOI, buffers: cell00OpeningBuffers })) { if (data?.type !== "FeatureCollection" || !Array.isArray(data.features)) throw new Error(`${name} must be a GeoJSON FeatureCollection.`); } // Points use the precomputed Lambert-93 distance from the Eiffel Tower. const cell00OpeningPoints = cell00OpeningRestaurants.features.flatMap(feature => { const p = feature.properties ?? {}; const xy = feature.geometry?.coordinates; const distance = p.distance_from_eiffeltower_m; if (feature.geometry?.type !== "Point" || !Array.isArray(xy) || !Number.isFinite(xy[0]) || !Number.isFinite(xy[1]) || !Number.isFinite(distance) || distance < 0 || distance > 1500) return []; const rating = Number.isFinite(p.rating) && p.rating >= 1 && p.rating <= 5 ? p.rating : null; return [{x: xy[0], y: xy[1], distance, rating, name: p.restaurant_name || "Unnamed restaurant"}]; }); // Each outline represents only its own 250 m annulus, not the cumulative circle. // Bands include the lower edge and exclude the upper edge, except 1500 m is included. const cell00OpeningBands = [250, 500, 750, 1000, 1250, 1500].map(radius => { const lower = radius - 250; const ratings = cell00OpeningPoints.filter(p => p.rating !== null && p.distance >= lower && (radius === 1500 ? p.distance <= radius : p.distance < radius)).map(p => p.rating); return {lower, radius, n: ratings.length, mean: ratings.length ? ratings.reduce((sum, rating) => sum + rating, 0) / ratings.length : null, median: ratings.length ? cell00OpeningD3.median(ratings) : null}; }); const cell00OpeningBufferFeatures = cell00OpeningBuffers.features.map(feature => { const match = /^buffer_(\d+)m$/.exec(feature.properties?.layer ?? ""); const band = cell00OpeningBands.find(d => d.radius === Number(match?.[1])); if (!band) throw new Error(`Unrecognized buffer layer: ${feature.properties?.layer}`); return {...feature, properties: {...feature.properties, ...band}}; }); if (cell00OpeningBufferFeatures.length !== cell00OpeningBands.length || new Set(cell00OpeningBufferFeatures.map(f => f.properties.radius)).size !== cell00OpeningBands.length) throw new Error("Expected one buffer for each radius from 250 to 1500 m."); // Find the southeast vertex of each supplied ring; north is positive y in EPSG:2154. // This uses the actual buffer geometry and needs no additional tower-point attachment. const cell00OpeningRingLabels = cell00OpeningBufferFeatures.map(feature => { const ring = feature.geometry.coordinates[0][0]; const centerX = (Math.min(...ring.map(p => p[0])) + Math.max(...ring.map(p => p[0]))) / 2; const centerY = (Math.min(...ring.map(p => p[1])) + Math.max(...ring.map(p => p[1]))) / 2; const [x, y] = ring.reduce((best, p) => (p[0] - centerX) - (p[1] - centerY) > (best[0] - centerX) - (best[1] - centerY) ? p : best); return {...feature.properties, x, y, label: feature.properties.median === null ? "—" : feature.properties.median.toFixed(3)}; }); const cell00OpeningMapWidth = Math.max(240, Math.min(width, 1100)); const cell00OpeningMapHeight = Math.round(cell00OpeningMapWidth * 0.86); // Fit an explicit planar projection to the AOI, with north up and an 8 px margin. // Reuse this exact projection for the scale bar below. const cell00OpeningProjection = cell00OpeningD3.geoIdentity().reflectY(true) .fitExtent([[8, 8], [cell00OpeningMapWidth - 8, cell00OpeningMapHeight - 8]], cell00OpeningAOI); // Center the fade on the buffer geometry and size it in the projected map's pixels. const cell00OpeningCenterRing = cell00OpeningBufferFeatures[0].geometry.coordinates[0][0]; const cell00OpeningCenter = [ (Math.min(...cell00OpeningCenterRing.map(p => p[0])) + Math.max(...cell00OpeningCenterRing.map(p => p[0]))) / 2, (Math.min(...cell00OpeningCenterRing.map(p => p[1])) + Math.max(...cell00OpeningCenterRing.map(p => p[1]))) / 2 ]; const [cell00OpeningVignetteX, cell00OpeningVignetteY] = cell00OpeningProjection(cell00OpeningCenter); const cell00OpeningFadeStartPoint = cell00OpeningProjection([cell00OpeningCenter[0] + cell00OpeningVignetteStartMeters, cell00OpeningCenter[1]]); const cell00OpeningFadeStart = Math.hypot(cell00OpeningFadeStartPoint[0] - cell00OpeningVignetteX, cell00OpeningFadeStartPoint[1] - cell00OpeningVignetteY); const cell00OpeningFadeRadius = Math.max(...[[0, 0], [cell00OpeningMapWidth, 0], [0, cell00OpeningMapHeight], [cell00OpeningMapWidth, cell00OpeningMapHeight]] .map(([x, y]) => Math.hypot(x - cell00OpeningVignetteX, y - cell00OpeningVignetteY))); const cell00OpeningFadeOffset = Math.min(100, 100 * cell00OpeningFadeStart / cell00OpeningFadeRadius); const cell00OpeningFadeId = `cell00Opening-fade-${Math.random().toString(36).slice(2)}`; // Draw buildings first and the tower last, regardless of feature order in the file. const cell00OpeningSources = [...new Set(cell00OpeningBasemap.features.map(f => f.properties?.source))]; const cell00OpeningSourceOrder = ["batiments", ...cell00OpeningSources.filter(source => !["batiments", "Parcs", "La Seine", "Tour Eiffel"].includes(source)), "Parcs", "La Seine", "Tour Eiffel"].filter(source => cell00OpeningSources.includes(source)); const cell00OpeningMap = cell00OpeningPlot.plot({ width: cell00OpeningMapWidth, height: cell00OpeningMapHeight, margin: 8, projection: cell00OpeningProjection, color: cell00OpeningRatingScale, style: {background: cell00OpeningBackground, color: "#1f2933", fontFamily: cell00OpeningFont}, marks: [ // Separate marks make every source color a literal, independent of the rating scale. ...cell00OpeningSourceOrder.map(source => cell00OpeningPlot.geo(cell00OpeningBasemap.features.filter(f => f.properties?.source === source), { fill: cell00OpeningBasemapColors[source] ?? cell00OpeningUnknownSourceColor, stroke: "none" })), // The fade is above the basemap but below all circles, points, and labels. () => cell00OpeningHtl.svg` `, cell00OpeningPlot.geo(cell00OpeningBufferFeatures.filter(f => f.properties.median !== null), { fill: "none", stroke: f => f.properties.median, strokeWidth: 2, strokeDasharray: `${cell00OpeningRingDashLength},${cell00OpeningRingDashGap}`, strokeOpacity: cell00OpeningRingOpacity, strokeLinecap: "round", title: f => `${f.properties.lower}–${f.properties.radius} m band\nMedian rating: ${f.properties.median.toFixed(3)} / 5\nRated restaurants: ${f.properties.n}` }), cell00OpeningPlot.geo(cell00OpeningBufferFeatures.filter(f => f.properties.median === null), { fill: "none", stroke: cell00OpeningMissingRatingColor, strokeWidth: 2, strokeDasharray: `${cell00OpeningRingDashLength},${cell00OpeningRingDashGap}`, strokeOpacity: cell00OpeningRingOpacity, strokeLinecap: "round", title: f => `${f.properties.lower}–${f.properties.radius} m band\nNo rated restaurants` }), cell00OpeningPlot.dot(cell00OpeningPoints.filter(p => p.rating === null), { x: "x", y: "y", r: 3 * 96 / 72, fill: cell00OpeningMissingRatingColor, stroke: "none", title: p => `${p.name}\nNo rating\nDistance: ${Math.round(p.distance)} m` }), // SVG paints later points on top: draw high-rated blue before low-rated red. cell00OpeningPlot.dot(cell00OpeningPoints.filter(p => p.rating !== null).sort((a, b) => b.rating - a.rating), { x: "x", y: "y", r: 3 * 96 / 72, fill: "rating", stroke: "none", title: p => `${p.name}\nRating: ${p.rating.toFixed(2)} / 5\nDistance: ${Math.round(p.distance)} m` }), // Labels and outlines use the same band median and shared rating scale. cell00OpeningPlot.text(cell00OpeningRingLabels.filter(d => d.median !== null), { x: "x", y: "y", text: "label", fill: "median", stroke: "white", strokeWidth: 3, paintOrder: "stroke", fontFamily: cell00OpeningFont, fontSize: 11, fontWeight: 600, title: d => `${d.lower}–${d.radius} m band\nMedian rating: ${d.label} / 5\nRated restaurants: ${d.n}` }), cell00OpeningPlot.text(cell00OpeningRingLabels.filter(d => d.median === null), { x: "x", y: "y", text: "label", fill: cell00OpeningMissingRatingColor, stroke: "white", strokeWidth: 3, paintOrder: "stroke", fontFamily: cell00OpeningFont, fontSize: 11, fontWeight: 600, title: d => `${d.lower}–${d.radius} m band\nNo rated restaurants` }) ] }); // Measure 500 projected metres in SVG pixels so the bar stays correct when resized. const cell00OpeningScaleStart = cell00OpeningProjection([648000, 6862000]); const cell00OpeningScaleEnd = cell00OpeningProjection([648500, 6862000]); const cell00OpeningScaleLength = Math.hypot(cell00OpeningScaleEnd[0] - cell00OpeningScaleStart[0], cell00OpeningScaleEnd[1] - cell00OpeningScaleStart[1]); // Center the scale and its headings together, with room for the CRS text. const cell00OpeningScaleCenterX = Math.max(90, 18 + cell00OpeningScaleLength / 2); const cell00OpeningScaleX = cell00OpeningScaleCenterX - cell00OpeningScaleLength / 2; const cell00OpeningScaleY = cell00OpeningMapHeight - 27; // These decorations use SVG coordinates; their positions scale with the map. cell00OpeningMap.append(cell00OpeningHtl.svg` RGF93 / Lambert-93 · EPSG:2154 Scale 1:10,000 0 500 m `); const cell00OpeningLegend = cell00OpeningPlot.legend({ color: {...cell00OpeningRatingScale, label: "TripAdvisor Mean Rating"}, width: Math.min(cell00OpeningMapWidth - 80, 140), height: 46, marginLeft: 8, marginRight: 8, ticks: [1, 5], tickFormat: ".0f", style: {fontFamily: cell00OpeningFont} }); // Keep legend text readable over the map without an opaque panel. cell00OpeningLegend.querySelectorAll("text").forEach(text => { text.setAttribute("stroke", "white"); text.setAttribute("stroke-width", "3"); text.setAttribute("stroke-linejoin", "round"); text.setAttribute("paint-order", "stroke"); }); // A dashed gradient echoes the ring outlines and shares the point rating scale. const cell00OpeningMedianLegendWidth = Math.min(cell00OpeningMapWidth - 80, 140); const cell00OpeningMedianLegendColor = cell00OpeningD3.scaleLinear().domain(cell00OpeningRatingScale.domain) .range(cell00OpeningRatingScale.range).interpolate(cell00OpeningD3.interpolateRgb).clamp(true); const cell00OpeningMedianLegendSpan = cell00OpeningMedianLegendWidth - 16; // Give each dash a literal color, avoiding SVG gradient references on a zero-height line. const cell00OpeningMedianLegendStep = cell00OpeningRingDashLength + cell00OpeningRingDashGap; const cell00OpeningMedianLegendDashes = Array.from({length: Math.ceil(cell00OpeningMedianLegendSpan / cell00OpeningMedianLegendStep)}, (_, i) => { const start = i * cell00OpeningMedianLegendStep; const end = Math.min(start + cell00OpeningRingDashLength, cell00OpeningMedianLegendSpan); const rating = 1 + 4 * (start + end) / (2 * cell00OpeningMedianLegendSpan); return {x1: 8 + start, x2: 8 + end, color: cell00OpeningMedianLegendColor(rating)}; }); const cell00OpeningMedianLegend = cell00OpeningHtl.svg``; // Overview uses the full Paris point dataset from Cell 02 with a muted color scale. // The actual AOI geometry, rather than an approximated square, is outlined in brown. const cell00OpeningInsetRatingScale = { type: "linear", domain: [1, 5], range: ["#c2c2c2", "#666666"], interpolate: "rgb", clamp: true }; const cell00OpeningInsetPoints = cell00OpeningRestaurants.features.flatMap(feature => { const xy = feature.geometry?.coordinates; if (feature.geometry?.type !== "Point" || !Array.isArray(xy) || !Number.isFinite(xy[0]) || !Number.isFinite(xy[1])) return []; const rating = feature.properties?.rating; return [{x: xy[0], y: xy[1], rating: Number.isFinite(rating) && rating >= 1 && rating <= 5 ? rating : null}]; }); const cell00OpeningInsetWidth = Math.round(0.75 * Math.min(190, Math.max(70, Math.round(cell00OpeningMapWidth * 0.22)))); const cell00OpeningInsetAOIColor = "#bd8b63"; const cell00OpeningInset = cell00OpeningPlot.plot({ width: cell00OpeningInsetWidth, height: Math.round(cell00OpeningInsetWidth * 0.83), margin: 4, projection: {type: "reflect-y", domain: {type: "MultiPoint", coordinates: cell00OpeningInsetPoints.map(p => [p.x, p.y])}}, color: cell00OpeningInsetRatingScale, style: {background: "transparent", fontFamily: cell00OpeningFont}, marks: [ cell00OpeningPlot.dot(cell00OpeningInsetPoints.filter(p => p.rating === null), { x: "x", y: "y", r: 0.85, fill: cell00OpeningMissingRatingColor, stroke: "none" }), cell00OpeningPlot.dot(cell00OpeningInsetPoints.filter(p => p.rating !== null).sort((a, b) => b.rating - a.rating), { x: "x", y: "y", r: 0.85, fill: "rating", stroke: "none" }), cell00OpeningPlot.geo(cell00OpeningAOI, {fill: "none", stroke: cell00OpeningInsetAOIColor, strokeWidth: 3}) ] }); // Self-contained version of Cell 07's unadjusted GAM and sensitivity fits. const cell00OpeningGamRows = cell00OpeningRestaurants.features.map(f => ({...f.properties, rating: f.properties?.rating, distance: f.properties?.distance_from_eiffeltower_m })).filter(d => Number.isFinite(d.rating) && Number.isFinite(d.distance) && d.distance >= 0 && d.distance <= 1500); if (cell00OpeningGamRows.length < 30) throw new Error("Too few ratings and distances for the GAM."); const cell00OpeningGamMin = Math.min(...cell00OpeningGamRows.map(d => d.distance)); const cell00OpeningGamMax = Math.max(...cell00OpeningGamRows.map(d => d.distance)); function cell00OpeningGamSpec(k, min = cell00OpeningGamMin, max = cell00OpeningGamMax) { const degree = 3, interior = k - degree - 1; if (k < 4 || !(max > min)) throw new Error("Invalid spline specification."); return {k, min, max, knots: [...Array(4).fill(0), ...Array.from({length: interior}, (_, i) => (i + 1) / (interior + 1)), ...Array(4).fill(1)]}; } function cell00OpeningGamBasis(distance, spec) { if (distance < spec.min - 1e-9 || distance > spec.max + 1e-9) throw new Error("Prediction outside observed range."); const x = Math.max(0, Math.min(1, (distance - spec.min) / (spec.max - spec.min))); if (x === 1) return Array.from({length: spec.k}, (_, i) => +(i === spec.k - 1)); const t = spec.knots; let b = Array.from({length: t.length - 1}, (_, i) => +(t[i] <= x && x < t[i + 1])); for (let p = 1; p <= 3; p++) b = Array.from({length: t.length - p - 1}, (_, i) => (t[i + p] > t[i] ? (x - t[i]) / (t[i + p] - t[i]) * b[i] : 0) + (t[i + p + 1] > t[i + 1] ? (t[i + p + 1] - x) / (t[i + p + 1] - t[i + 1]) * b[i + 1] : 0)); return b; } function cell00OpeningGamPenalty(k, p) { const s = Array.from({length: p}, () => Array(p).fill(0)); for (let i = 0; i < k - 2; i++) for (let a = 0; a < 3; a++) for (let b = 0; b < 3; b++) s[i + a][i + b] += [1, -2, 1][a] * [1, -2, 1][b]; return s; } // Cholesky factorization solves the small positive-definite penalized system; // fail explicitly on rank deficiency instead of quietly adding a ridge penalty. function cell00OpeningGamCholesky(a) { const n = a.length, l = Array.from({length: n}, () => Array(n).fill(0)); for (let i = 0; i < n; i++) for (let j = 0; j <= i; j++) { let v = a[i][j]; for (let k = 0; k < j; k++) v -= l[i][k] * l[j][k]; if (i === j) { if (!(v > 1e-12)) throw new Error("Rank-deficient model matrix."); l[i][j] = Math.sqrt(v); } else l[i][j] = v / l[j][j]; } return l; } function cell00OpeningGamSolve(l, b) { const n = b.length, y = Array(n), x = Array(n); for (let i = 0; i < n; i++) { let v = b[i]; for (let j = 0; j < i; j++) v -= l[i][j] * y[j]; y[i] = v / l[i][i]; } for (let i = n - 1; i >= 0; i--) { let v = y[i]; for (let j = i + 1; j < n; j++) v -= l[j][i] * x[j]; x[i] = v / l[i][i]; } return x; } const cell00OpeningGamDot = (a, b) => a.reduce((s, x, i) => s + x * b[i], 0); const cell00OpeningGamLambdas = Array.from({length: 29}, (_, i) => 10 ** (-4 + i * 0.25)); function cell00OpeningGamFit(rows, spec, controls = () => [], lambdas = cell00OpeningGamLambdas) { const x = rows.map(d => [...cell00OpeningGamBasis(d.distance, spec), ...controls(d)]), y = rows.map(d => d.rating); const n = x.length, p = x[0].length; if (n <= p) throw new Error("Not enough observations for the model."); const cross = Array.from({length: p}, () => Array(p).fill(0)), xy = Array(p).fill(0); let yy = 0; for (let r = 0; r < n; r++) { yy += y[r] ** 2; for (let i = 0; i < p; i++) { xy[i] += x[r][i] * y[r]; for (let j = 0; j <= i; j++) cross[i][j] += x[r][i] * x[r][j]; }} for (let i = 0; i < p; i++) for (let j = 0; j < i; j++) cross[j][i] = cross[i][j]; const penalty = cell00OpeningGamPenalty(spec.k, p); let best = null; const smoothingScores = []; for (const lambda of lambdas) { let l; try { l = cell00OpeningGamCholesky(cross.map((row, i) => row.map((v, j) => v + lambda * penalty[i][j]))); } catch { continue; } const beta = cell00OpeningGamSolve(l, xy); let edf = 0; for (let j = 0; j < p; j++) edf += cell00OpeningGamSolve(l, cross.map(row => row[j]))[j]; // Algebraic SSE avoids repeated passes over observations for each lambda. const sse = Math.max(0, yy - 2 * cell00OpeningGamDot(beta, xy) + cell00OpeningGamDot(beta, cross.map(row => cell00OpeningGamDot(row, beta)))); const gcv = n * sse / (n - edf) ** 2; if (Number.isFinite(gcv)) smoothingScores.push({lambda, gcv}); if (Number.isFinite(gcv) && (!best || gcv < best.gcv)) best = {beta, edf, sse, gcv, lambda}; } if (!best) throw new Error("No numerically valid fit; inspect the model matrix."); const mean = y.reduce((a, b) => a + b, 0) / n, sst = y.reduce((a, b) => a + (b - mean) ** 2, 0); const predict = (distance, controlVector = Array(p - spec.k).fill(0)) => cell00OpeningGamDot([...cell00OpeningGamBasis(distance, spec), ...controlVector], best.beta); const fitted = x.map(row => cell00OpeningGamDot(row, best.beta)); return {...best, n, spec, fitted, smoothingScores, residuals: y.map((v, i) => v - fitted[i]), predict, rmse: Math.sqrt(best.sse / n), residualSD: Math.sqrt(best.sse / (n - best.edf)), r2: sst > 0 ? 1 - best.sse / sst : null}; } const cell00OpeningGamSpec10 = cell00OpeningGamSpec(10); const cell00OpeningGamPrimary = cell00OpeningGamFit(cell00OpeningGamRows, cell00OpeningGamSpec10); const cell00OpeningGamLeaveOneOut = cell00OpeningGamRows.filter(row => row.distance < 250).map(row => { const sample = cell00OpeningGamRows.filter(d => d !== row); return {fit: cell00OpeningGamFit(sample, cell00OpeningGamSpec10), min: Math.min(...sample.map(d => d.distance)), max: Math.max(...sample.map(d => d.distance))}; }); const cell00OpeningGamReviewSample = cell00OpeningGamRows.filter(row => Number.isFinite(row.reviews_count_in_default_language) && row.reviews_count_in_default_language >= 5); const cell00OpeningGamReviewFit = cell00OpeningGamReviewSample.length > 30 ? cell00OpeningGamFit(cell00OpeningGamReviewSample, cell00OpeningGamSpec10) : null; const cell00OpeningGamReviewMin = cell00OpeningGamReviewFit ? Math.min(...cell00OpeningGamReviewSample.map(d => d.distance)) : null; const cell00OpeningGamReviewMax = cell00OpeningGamReviewFit ? Math.max(...cell00OpeningGamReviewSample.map(d => d.distance)) : null; const cell00OpeningGamGrid = Array.from({length: 201}, (_, i) => i === 200 ? cell00OpeningGamMax : cell00OpeningGamMin + (cell00OpeningGamMax - cell00OpeningGamMin) * i / 200); const cell00OpeningGamCurve = (fit, min, max) => cell00OpeningGamGrid.filter(distance => distance >= min && distance <= max) .map(distance => ({distance, predicted: fit.predict(distance)})); const cell00OpeningGamOriginalWidth = Math.min(290, Math.max(170, Math.round(cell00OpeningMapWidth * 0.35)), cell00OpeningMapWidth - 24); const cell00OpeningGamWidth = Math.round(1.25 * Math.round(cell00OpeningGamOriginalWidth / 2)); const cell00OpeningGamHeight = Math.round(0.75 * Math.round(1.25 * Math.round(1.5 * Math.round(Math.max(120, Math.round(cell00OpeningGamOriginalWidth * 0.58)) / 2)))); const cell00OpeningGamPlot = cell00OpeningPlot.plot({ width: cell00OpeningGamWidth, height: cell00OpeningGamHeight, marginTop: 9, marginRight: 29, marginBottom: 21, marginLeft: 3, x: {domain: [0, 1500], ticks: [0, 500, 1000, 1500], label: "Distance (m)", tickSize: 0}, y: {domain: [1, 5], axis: "right", ticks: [1, 2, 3, 4, 5], label: null, tickSize: 0}, color: cell00OpeningRatingScale, style: {background: "transparent", color: "#303940", fontFamily: cell00OpeningFont, fontSize: "8.75px"}, marks: [ cell00OpeningPlot.ruleX(cell00OpeningBands.filter(b => b.median !== null), { x: "radius", stroke: "median", strokeWidth: 1, strokeDasharray: `${cell00OpeningRingDashLength},${cell00OpeningRingDashGap}`, strokeOpacity: cell00OpeningRingOpacity, clip: true }), cell00OpeningPlot.ruleX(cell00OpeningBands.filter(b => b.median === null), { x: "radius", stroke: cell00OpeningMissingRatingColor, strokeWidth: 1, strokeDasharray: `${cell00OpeningRingDashLength},${cell00OpeningRingDashGap}`, strokeOpacity: cell00OpeningRingOpacity, clip: true }), ...cell00OpeningGamLeaveOneOut.map(({fit, min, max}) => cell00OpeningPlot.line(cell00OpeningGamCurve(fit, min, max), { x: "distance", y: "predicted", stroke: "#d4c4ed", strokeOpacity: 0.9, strokeWidth: 1.4, clip: true })), ...(cell00OpeningGamReviewFit ? [cell00OpeningPlot.line(cell00OpeningGamCurve(cell00OpeningGamReviewFit, cell00OpeningGamReviewMin, cell00OpeningGamReviewMax), { x: "distance", y: "predicted", stroke: "#c29cdb", strokeWidth: 2, strokeDasharray: "4,3", clip: true })] : []), cell00OpeningPlot.line(cell00OpeningGamCurve(cell00OpeningGamPrimary, cell00OpeningGamMin, cell00OpeningGamMax), { x: "distance", y: "predicted", stroke: "#aa91d0", strokeWidth: 2.5, clip: true }), // Mark the Eiffel Tower at the zero-distance end of the horizontal axis. cell00OpeningPlot.dot([{distance: 0, rating: 1}], { x: "distance", y: "rating", symbol: "triangle", r: 3, dy: -4, fill: cell00OpeningBasemapColors["Tour Eiffel"], stroke: "none" }) ] }); const cell00OpeningGamAxisX = cell00OpeningGamWidth - 3; const cell00OpeningGamAxisY = 9 + (cell00OpeningGamHeight - 9 - 21) / 2; cell00OpeningGamPlot.append(cell00OpeningHtl.svg`Predicted rating`); cell00OpeningGamPlot.querySelectorAll("text").forEach(text => { text.setAttribute("stroke", "white"); text.setAttribute("stroke-width", "2"); text.setAttribute("stroke-linejoin", "round"); text.setAttribute("paint-order", "stroke"); }); // Native SVG title tooltips use browser-controlled fonts. Convert them into one // styled popup while keeping the same text as accessible labels on the marks. const cell00OpeningPopupText = new WeakMap(); cell00OpeningMap.querySelectorAll("title").forEach(title => { const mark = title.parentNode; if (mark === cell00OpeningMap) return; cell00OpeningPopupText.set(mark, title.textContent); mark.setAttribute("aria-label", title.textContent); title.remove(); }); const cell00OpeningPopup = cell00OpeningHtl.html``; const cell00OpeningMapContainer = cell00OpeningHtl.html`

${cell00OpeningMap}

${cell00OpeningTitle}

${cell00OpeningSubtitle}

${cell00OpeningLegend} ${cell00OpeningMedianLegend}

Ring increments: 250 m

Paris AOI

${cell00OpeningInset}

${cell00OpeningGamPlot}

GAM sensitivity fits

${cell00OpeningPopup}

`; cell00OpeningMap.addEventListener("pointermove", event => { let target = event.target; while (target && target !== cell00OpeningMap && !cell00OpeningPopupText.has(target)) target = target.parentNode; const value = target && cell00OpeningPopupText.get(target); if (!value) { cell00OpeningPopup.style.display = "none"; return; } cell00OpeningPopup.textContent = value; cell00OpeningPopup.style.display = "block"; const bounds = cell00OpeningMapContainer.getBoundingClientRect(); const x = event.clientX - bounds.left + 12; const y = event.clientY - bounds.top + 12; cell00OpeningPopup.style.left = `${Math.max(0, Math.min(x, bounds.width - cell00OpeningPopup.offsetWidth))}px`; cell00OpeningPopup.style.top = `${Math.max(0, Math.min(y, bounds.height - cell00OpeningPopup.offsetHeight))}px`; }); cell00OpeningMap.addEventListener("pointerleave", () => { cell00OpeningPopup.style.display = "none"; }); display(cell00OpeningHtl.html`

${cell00OpeningMapContainer}

Dashed circles and labels show the median rating in each 250 m band. Gray indicates no rating.

${cell00OpeningBands.map(b => `${b.lower}–${b.radius} m: ${b.median === null ? "no ratings" : `median ${b.median.toFixed(3)} (n=${b.n})`}`).join(" · ")}

GAM inset: lavender = primary fit; pale lavender = omit one restaurant within 250 m; dashed lavender = at least five reviews in the default language. Curves show fitted mean ratings within each sample's observed distances; sensitivity curves are not confidence intervals.

Scale 1:10,000 when the 500 m bar measures 5 cm on the printed or displayed map.

`); 4c:Td19,// Cell 02 — paste this entire file into one Observable JavaScript or TypeScript cell. // Attach restaurants_paris.geojson to the notebook before running it. import * as cell02Plot from "npm:@observablehq/plot"; import * as cell02Htl from "npm:htl"; const restaurants = await FileAttachment("restaurants_paris.geojson").json(); const ratingColors = { type: "linear", domain: [1, 1.5, 2.5, 3.5, 4.5, 5], range: ["#a50026", "#a50026", "#f6a09a", "#a6cee3", "#08306b", "#08306b"], interpolate: "rgb", clamp: true, label: "Average rating (out of 5)" }; const restaurantMap = (() => { const mapWidth = Math.max(240, Math.min(width, 1100)); const pointRadius = 1.6; const noRatingColor = "#d1d5db"; const points = restaurants.features .filter(d => d.geometry?.type === "Point" && d.geometry.coordinates.slice(0, 2).length === 2 && d.geometry.coordinates.slice(0, 2).every(Number.isFinite)) .map(d => ({ x: d.geometry.coordinates[0], y: d.geometry.coordinates[1], name: d.properties?.restaurant_name ?? "Unnamed restaurant", // Missing ratings are not low ratings. rating: Number.isFinite(d.properties?.rating) && d.properties.rating >= 1 && d.properties.rating <= 5 ? d.properties.rating : null })); if (!points.length) throw new Error("No valid Point geometries found."); // SVG draws later points on top: highest ratings first, lowest ratings last. const rated = points.filter(d => d.rating !== null) .sort ( (a, b) => b.rating - a.rating ); const unrated = points.filter(d => d.rating === null); const domain = { type: "MultiPoint", coordinates: points.map(d => [d.x, d.y]) }; const map = cell02Plot.plot({ width: mapWidth, height: Math.round(mapWidth * 0.83), margin: 12, // The coordinates are in EPSG:2154 (Lambert-93); north is up. projection: {type: "reflect-y", domain}, color: ratingColors, style: {background: "white", color: "#111827"}, marks: [ cell02Plot.dot(unrated, { x: "x", y: "y", r: pointRadius, fill: noRatingColor, title: d => `${d.name}\nNo rating` }), cell02Plot.dot(rated, { x: "x", y: "y", r: pointRadius, fill: "rating", title: d => `${d.name}\nAverage rating: ${d.rating.toFixed(1)} / 5` }) ] }); const legend = cell02Plot.legend({ color: ratingColors, width: Math.min(mapWidth, 460), height: 52, marginLeft: 8, marginRight: 8, ticks: [1, 2, 3, 4, 5], tickFormat: ".0f", style: {background: "white", color: "#111827"} }); return cell02Htl.html`

Average TripAdvisor Restaurant Ratings in Paris

${legend} ${unrated.length ? cell02Htl.html`

No rating

` : null} ${map} `; })(); display(restaurantMap); 4d:Tbd0,// Cell 01 — paste this entire file into one Observable JavaScript or TypeScript cell. // Attach restaurants_paris.geojson to the notebook before running it. import * as Plot from "npm:@observablehq/plot"; import * as Inputs from "npm:@observablehq/inputs"; import * as d3 from "npm:d3"; const parisGeoJSON = await FileAttachment("restaurants_paris.geojson").json(); const parisRestaurants = parisGeoJSON.features.map((feature) => feature.properties ?? {}); // Treat only finite numeric values as observations; in particular, null is not zero. const numericValues = (column) => parisRestaurants .map((restaurant) => restaurant[column]) .filter((value) => typeof value === "number" && Number.isFinite(value)); const ratingValues = numericValues("rating"); // Work in tenths to align bin edges at 3.0, 3.1, and so on. const ratingBinStart = ratingValues.length ? Math.floor(d3.min(ratingValues) * 10) : 0; const ratingBinEnd = ratingValues.length ? Math.max(ratingBinStart + 1, Math.ceil(d3.max(ratingValues) * 10)) : 10; const ratingBinThresholds = d3.range(ratingBinStart + 1, ratingBinEnd).map((i) => i / 10); // Precompute bins so the hover tooltip can report the exact range and count. const ratingBins = d3.bin() .domain([ratingBinStart / 10, ratingBinEnd / 10]) .thresholds(ratingBinThresholds)(ratingValues); const summaryColumns = [ "rating", "distance_from_eiffeltower_m", "total_reviews_count", "excellent", "terrible" ]; const parisSummary = summaryColumns.map((column) => { const values = numericValues(column).sort((a, b) => a - b); const q1 = d3.quantileSorted(values, 0.25); const q3 = d3.quantileSorted(values, 0.75); return { column, n: values.length, missing: parisRestaurants.length - values.length, mean: d3.mean(values) ?? null, median: d3.median(values) ?? null, std: d3.deviation(values) ?? null, IQR: q1 == null || q3 == null ? null : q3 - q1, min: d3.min(values) ?? null, max: d3.max(values) ?? null }; }); // Feature properties form the table; the original geometry remains in parisGeoJSON. display(Inputs.table(parisRestaurants, {label: "Paris restaurants"})); display(htl.html`

Total records: ${parisRestaurants.length.toLocaleString()}

`); display(Plot.plot({ title: "Distribution of restaurant ratings", x: {label: "Rating", domain: [ratingBinStart / 10, ratingBinEnd / 10]}, y: {label: "Number of points"}, marks: [ Plot.rectY(ratingBins, { x1: (bin) => bin.x0, x2: (bin) => bin.x1, y: (bin) => bin.length, fill: (bin) => bin.x0 < 2 ? "#a50f15" : bin.x0 < 3 ? "#fb6a6a" : bin.x0 < 4 ? "#9ecae1" : "#08519c", title: (bin) => `Rating: ${bin.x0.toFixed(1)}–${bin.x1.toFixed(1)}\nPoints: ${bin.length.toLocaleString()}`, tip: true }), Plot.ruleX([2, 3, 4], {stroke: "#333", strokeOpacity: 0.45, strokeDasharray: "2,4"}) ] })); display(Inputs.table(parisSummary, {label: "Summary statistics"})); 4e:T4352,// Cell 03 — paste this entire file into one Observable JavaScript or TypeScript cell. // Attach restaurants_paris.geojson to the notebook before running it. import * as cell03Inputs from "npm:@observablehq/inputs"; import * as cell03Htl from "npm:htl"; import * as cell03Plot from "npm:@observablehq/plot"; import cell03JStatPackage from "npm:jstat"; const cell03JStat = cell03JStatPackage.jStat ?? cell03JStatPackage; const cell03GeoJSON = await FileAttachment("restaurants_paris.geojson").json(); const cell03Restaurants = cell03GeoJSON.features.map(feature => feature.properties ?? {}); const cell03PriceCodes = new Map([["€", 1], ["€€-€€€", 2], ["€€€€", 3]]); const cell03First = value => typeof value === "string" ? value.split(",")[0].trim() || null : null; const cell03CuisineGroup = value => { const first = cell03First(value); return first === null ? null : ["French", "European", "Japanese"].includes(first) ? first : "Other cuisines"; }; // Solve Xβ = y by modified Gram–Schmidt QR, avoiding inversion of X'X. // The second coefficient is always distance, expressed in kilometres. function cell03Fit(rows, adjusted) { let cuisines = []; let reference = null; if (adjusted) { const groupCounts = new Map(); for (const row of rows) groupCounts.set(row.cuisine, (groupCounts.get(row.cuisine) ?? 0) + 1); const groups = Array.from(groupCounts.keys()).sort((a, b) => groupCounts.get(b) - groupCounts.get(a) || String(a).localeCompare(String(b))); reference = groups[0]; cuisines = groups.slice(1); } const columns = [rows.map(() => 1), rows.map(row => row.distance / 1000)]; if (adjusted) { columns.push(rows.map(row => row.price)); columns.push(rows.map(row => row.award)); for (const cuisine of cuisines) columns.push(rows.map(row => +(row.cuisine === cuisine))); } const n = rows.length, p = columns.length, df = n - p; if (df <= 0) throw new Error("Not enough complete observations for this model."); const q = [], r = Array.from({length: p}, () => Array(p).fill(0)); for (let j = 0; j < p; j++) { const v = columns[j].slice(); for (let k = 0; k < j; k++) { let dot = 0; for (let i = 0; i < n; i++) dot += q[k][i] * v[i]; r[k][j] = dot; for (let i = 0; i < n; i++) v[i] -= dot * q[k][i]; } r[j][j] = Math.hypot(...v); if (r[j][j] < 1e-10) throw new Error("The model is singular; a predictor has no independent variation."); q.push(v.map(value => value / r[j][j])); } const qty = q.map(column => column.reduce((sum, value, i) => sum + value * rows[i].rating, 0)); const beta = Array(p).fill(0); for (let j = p - 1; j >= 0; j--) { let value = qty[j]; for (let k = j + 1; k < p; k++) value -= r[j][k] * beta[k]; beta[j] = value / r[j][j]; } let sse = 0, sst = 0; const mean = rows.reduce((sum, row) => sum + row.rating, 0) / n; for (let i = 0; i < n; i++) { let predicted = 0; for (let j = 0; j < p; j++) predicted += columns[j][i] * beta[j]; sse += (rows[i].rating - predicted) ** 2; sst += (rows[i].rating - mean) ** 2; } // Row 1 of R⁻¹ gives the distance coefficient's diagonal entry in (X'X)⁻¹. const inverseDistanceRow = Array(p).fill(0); for (let j = 0; j < p; j++) { let value = j === 1 ? 1 : 0; for (let k = 0; k < j; k++) value -= inverseDistanceRow[k] * r[k][j]; inverseDistanceRow[j] = value / r[j][j]; } const se = Math.sqrt(sse / df * inverseDistanceRow.reduce((sum, value) => sum + value ** 2, 0)); if (!(se > 0) || !Number.isFinite(se)) throw new Error("The distance standard error is undefined."); const t = beta[1] / se; const critical = cell03JStat.studentt.inv(0.975, df); // Evaluate the lower tail directly for numerical accuracy with large |t|. const pValue = Math.min(1, 2 * cell03JStat.studentt.cdf(-Math.abs(t), df)); return {n, df, mse: sse / df, estimate: beta[1], se, t, pValue, low: beta[1] - critical * se, high: beta[1] + critical * se, r2: sst > 0 ? 1 - sse / sst : null, reference}; } const cell03Scope = cell03Inputs.radio(["All Paris restaurants", "Within 1.5 km"], { label: "Restaurants to include", value: "Within 1.5 km" }); const cell03ReviewCheck = cell03Htl.html``; const cell03ReviewFloor = cell03Htl.html``; cell03ReviewFloor.hidden = true; const cell03ScopeRow = cell03Htl.html`

${cell03Scope} ${cell03ReviewCheck} Exclude low review count ${cell03ReviewFloor}

`; const cell03Mode = cell03Inputs.radio(["Linear Regression Model", "Price Level", "Cuisine", "Awarded"], { label: "Plot variables", value: "Linear Regression Model" }); const cell03LogCheck = cell03Htl.html``; const cell03ScaleRow = cell03Htl.html`

Scale ${cell03LogCheck} Logarithmic x-axis

`; const cell03TableResults = cell03Htl.html`

`; const cell03ChartResults = cell03Htl.html`

`; // Each chart mode remembers its hidden groups when other controls change. const cell03Visibility = new Map(); const cell03View = cell03Htl.html`

Restaurant rating and distance from the Eiffel Tower

${cell03ScopeRow}${cell03TableResults}

Scatterplot

${cell03Mode}${cell03ScaleRow}${cell03ChartResults}

`; function cell03Update() { const floorText = cell03ReviewFloor.value.trim(); const reviewFloor = Number(floorText); if (cell03ReviewCheck.checked && (!floorText || !Number.isSafeInteger(reviewFloor) || reviewFloor < 0)) { cell03TableResults.replaceChildren(cell03Htl.html`

Enter a nonnegative whole number for the minimum review count.

`); cell03ChartResults.replaceChildren(); return; } const within = cell03Scope.value === "Within 1.5 km"; const selected = cell03Restaurants.filter(row => (!within || (Number.isFinite(row.distance_from_eiffeltower_m) && row.distance_from_eiffeltower_m <= 1500)) && (!cell03ReviewCheck.checked || (Number.isFinite(row.reviews_count_in_default_language) && row.reviews_count_in_default_language >= reviewFloor))); const usable = selected.filter(row => Number.isFinite(row.rating) && Number.isFinite(row.distance_from_eiffeltower_m) && row.distance_from_eiffeltower_m >= 0) .map(row => ({rating: row.rating, distance: row.distance_from_eiffeltower_m, price: cell03PriceCodes.get(row.price_level), priceLabel: row.price_level, cuisine: cell03CuisineGroup(row.cuisines), award: typeof row.awards === "string" && row.awards.trim() !== "" ? 1 : 0})); const complete = usable.filter(row => row.price !== undefined && row.cuisine !== null); const table = [], errors = []; let adjustedFit = null; for (const [model, rows, adjusted] of [ ["Unadjusted", usable, false], ["Controls: price + cuisine + awards", complete, true] ]) { try { const fit = cell03Fit(rows, adjusted); if (adjusted) adjustedFit = fit; table.push({Model: model, "Rating coefficient (per km)": fit.estimate, N: fit.n, Excluded: selected.length - fit.n, "Standard error": fit.se, "t statistic": fit.t, "p value": fit.pValue, "R²": fit.r2}); } catch (error) { errors.push(`${model}: ${error.message}`); } } const number = value => value == null ? "—" : value.toFixed(4); const pFormat = value => value < 0.0001 ? "< 0.0001" : value.toFixed(4); const starsFor = p => p == null || !Number.isFinite(p) ? "" : p < 0.01 ? "***" : p < 0.05 ? "**" : p < 0.10 ? "*" : ""; const coefficientFormat = (value, index, rows) => `${number(value)}${starsFor(rows[index]["p value"])}`; cell03TableResults.replaceChildren( ...(table.length ? [cell03Htl.html`

${cell03Inputs.table(table, { rows: 2, width: {Model: 250, "Rating coefficient (per km)": 180}, format: { "Rating coefficient (per km)": coefficientFormat, "Standard error": number, "t statistic": number, "p value": pFormat, "R²": number } })}

`] : []), ...errors.map(message => cell03Htl.html`

${message}

`) ); // Simple regression in actual kilometres, independent of the chart's x scale. const fitGroup = rows => { if (rows.length < 3) return null; const meanX = rows.reduce((sum, row) => sum + row.distance / 1000, 0) / rows.length; const meanY = rows.reduce((sum, row) => sum + row.rating, 0) / rows.length; let sxx = 0, sxy = 0; for (const row of rows) { const dx = row.distance / 1000 - meanX; sxx += dx * dx; sxy += dx * (row.rating - meanY); } if (!(sxx > 0)) return null; const estimate = sxy / sxx; const mse = rows.reduce((sum, row) => sum + (row.rating - meanY - estimate * (row.distance / 1000 - meanX)) ** 2, 0) / (rows.length - 2); const se = Math.sqrt(mse / sxx); const pValue = se > 0 ? Math.min(1, 2 * cell03JStat.studentt.cdf(-Math.abs(estimate / se), rows.length - 2)) : null; return {n: rows.length, df: rows.length - 2, estimate, mse, se, pValue}; }; // Holding controls at their sample means centers each fitted line at (mean x, mean y). const makeCurve = (rows, fit) => { const displayRows = cell03LogCheck.checked ? rows.filter(row => row.distance > 0) : rows; if (!fit || displayRows.length < 2) return []; const xs = rows.map(row => row.distance / 1000); const meanX = xs.reduce((sum, x) => sum + x, 0) / xs.length; const meanY = rows.reduce((sum, row) => sum + row.rating, 0) / rows.length; const critical = cell03JStat.studentt.inv(0.975, fit.df); const minX = Math.min(...displayRows.map(row => row.distance / 1000)); const maxX = Math.max(...displayRows.map(row => row.distance / 1000)); if (minX >= maxX) return []; return Array.from({length: 201}, (_, i) => { const fraction = i / 200; const x = cell03LogCheck.checked ? Math.exp(Math.log(minX) + fraction * (Math.log(maxX) - Math.log(minX))) : minX + fraction * (maxX - minX); const y = meanY + fit.estimate * (x - meanX); const margin = critical * Math.sqrt(fit.mse / fit.n + (x - meanX) ** 2 * fit.se ** 2); return {distance: x, y, low: y - margin, high: y + margin}; }); }; const mode = cell03Mode.value; const visibilityKey = name => `${mode}\u0000${name}`; const isVisible = name => cell03Visibility.get(visibilityKey(name)) !== false; const legendItem = (key, label, color, dashed = false) => { const input = cell03Htl.html``; input.checked = isVisible(key); input.addEventListener("change", () => { cell03Visibility.set(visibilityKey(key), input.checked); cell03Update(); }); const swatch = cell03Htl.html``; return cell03Htl.html`${input}${swatch}${label}`; }; const xOptions = cell03LogCheck.checked ? {type: "log", label: "Distance from the Eiffel Tower (km, log scale)"} : {type: "linear", label: "Distance from the Eiffel Tower (km)"}; const logSafe = rows => cell03LogCheck.checked ? rows.filter(row => row.distance > 0) : rows; const baselineKey = "baseline"; const baselineColor = "#111827"; let legendEntries = [], points = [], lineDefs = [], note = ""; if (mode === "Linear Regression Model") { // The baseline and grey points share one legend item in this view. legendEntries.push(legendItem(baselineKey, "Baseline and points", baselineColor, true)); legendEntries.push(legendItem("controlled", "Controls at sample means", "#00ffff")); if (isVisible(baselineKey)) { points = logSafe(usable).map(row => ({...row, group: "Restaurants"})); lineDefs.push({name: "Baseline", color: baselineColor, rows: usable, fit: fitGroup(usable), dashed: true}); } if (isVisible("controlled")) lineDefs.push({name: "Controls", color: "#00ffff", rows: complete, fit: adjustedFit}); } else { const grouped = usable.map(row => { let group = null; if (mode === "Price Level" && row.price !== undefined) group = row.priceLabel; if (mode === "Awarded") group = row.award ? "Award recorded" : "No recorded award"; if (mode === "Cuisine") group = row.cuisine; return {...row, group}; }).filter(row => row.group !== null); const groups = new Map(); for (const row of grouped) { if (!groups.has(row.group)) groups.set(row.group, []); groups.get(row.group).push(row); } const names = mode === "Price Level" ? ["€", "€€-€€€", "€€€€"].filter(name => groups.has(name)) : mode === "Awarded" ? ["No recorded award", "Award recorded"].filter(name => groups.has(name)) : ["French", "European", "Japanese", "Other cuisines"].filter(name => groups.has(name)); const colors = names.map(name => mode === "Price Level" ? ({"€": "#c89467", "€€-€€€": "#98613d", "€€€€": "#553018"})[name] : mode === "Awarded" ? name === "Award recorded" ? "#166534" : "#8e8fd4" : ({"French": "#173f73", "European": "#553018", "Japanese": "#b45309", "Other cuisines": "#800020"})[name]); legendEntries.push(legendItem(baselineKey, "Baseline (visible groups)", baselineColor, true)); let visibleRows = [], groupsWithoutLines = 0; for (let i = 0; i < names.length; i++) { const name = names[i], rows = groups.get(name), key = `group:${name}`; legendEntries.push(legendItem(key, name, colors[i])); if (!isVisible(key)) continue; visibleRows.push(...rows); const fit = fitGroup(rows); if (!fit) groupsWithoutLines++; lineDefs.push({name, color: colors[i], rows, fit}); } points = logSafe(visibleRows); if (isVisible(baselineKey)) lineDefs.push({name: "Baseline", color: baselineColor, rows: visibleRows, fit: fitGroup(visibleRows), dashed: true}); note = `Plot: ${points.length.toLocaleString()} visible restaurants; missing group values are excluded.${groupsWithoutLines ? ` ${groupsWithoutLines} visible group(s) lack enough observations or distance variation for a line.` : ""}`; } const curves = lineDefs.map(def => ({...def, curve: makeCurve(def.rows, def.fit)})).filter(def => def.curve.length); const marks = []; if (points.length) { if (mode === "Linear Regression Model") marks.push(cell03Plot.dot(points, {x: row => row.distance / 1000, y: "rating", fill: "#374151", r: 2, fillOpacity: 0.55})); else { const colorsByName = new Map(lineDefs.filter(def => !def.dashed).map(def => [def.name, def.color])); marks.push(cell03Plot.dot(points, {x: row => row.distance / 1000, y: "rating", fill: row => colorsByName.get(row.group), r: 2, fillOpacity: 0.5})); } } for (const def of curves) marks.push(cell03Plot.areaY(def.curve, {x: "distance", y1: "low", y2: "high", fill: def.color, fillOpacity: def.dashed ? 0.08 : 0.14})); for (const def of curves) marks.push(cell03Plot.lineY(def.curve, {x: "distance", y: "y", stroke: def.color, strokeWidth: def.dashed ? 2 : 2.5, strokeDasharray: def.dashed ? "3,4" : null})); for (let i = 0; i < curves.length; i++) { const def = curves[i], point = def.curve[Math.floor(def.curve.length * 0.65)]; marks.push(cell03Plot.text([{...point, label: `${number(def.fit.estimate)}${starsFor(def.fit.pValue)}`}], { x: "distance", y: "y", text: "label", fill: def.color, fontSize: 11, fontWeight: 700, textAnchor: "start", dx: 4, dy: -6 - (i % 3) * 10 })); } const legend = cell03Htl.html`

${legendEntries}Shading: 95% confidence bands

`; const chart = marks.length ? cell03Plot.plot({ width: Math.max(240, Math.min(width, 1100)), height: 420, marginLeft: 55, x: xOptions, y: {label: "Rating"}, color: {type: "identity"}, marks }) : null; cell03ChartResults.replaceChildren( legend, ...(note ? [cell03Htl.html`

${note}

`] : []), ...(chart ? [chart] : []) ); } cell03Scope.addEventListener("input", cell03Update); cell03Mode.addEventListener("input", cell03Update); cell03LogCheck.addEventListener("change", cell03Update); cell03ReviewCheck.addEventListener("change", () => { cell03ReviewFloor.hidden = !cell03ReviewCheck.checked; cell03Update(); }); cell03ReviewFloor.addEventListener("input", cell03Update); cell03Update(); display(cell03View); 4f:T1c16,// Cell 04 — paste this entire file into one Observable JavaScript or TypeScript cell. // Attach restaurants_paris.geojson to the notebook before running it. import * as cell04D3 from "npm:d3"; import * as cell04Htl from "npm:htl"; import cell04JStatPackage from "npm:jstat"; const cell04JStat = cell04JStatPackage.jStat ?? cell04JStatPackage; const cell04GeoJSON = await FileAttachment("restaurants_paris.geojson").json(); const cell04Features = cell04GeoJSON.features; const cell04Eligible = cell04Features.map(feature => feature.properties ?? {}) .filter(row => Number.isFinite(row.distance_from_eiffeltower_m) && row.distance_from_eiffeltower_m >= 0 && row.distance_from_eiffeltower_m <= 1500); const cell04Rows = cell04Eligible.filter(row => Number.isFinite(row.rating)) .map(row => ({distance: row.distance_from_eiffeltower_m, rating: row.rating})); // Assign the shared 500 m boundary to the farther group, so the groups do not overlap. const cell04Near = cell04Rows.filter(row => row.distance < 500); const cell04Far = cell04Rows.filter(row => row.distance >= 500); const cell04Results = cell04Htl.html`

Calculating correlations and bootstrap intervals…

`; const cell04View = cell04Htl.html`

${cell04Results}

`; display(cell04View); // A worker keeps the resampling off the notebook's main thread. Each bootstrap // sample resamples restaurants as paired distance–rating observations and // recomputes average ranks, including ties, in that sample. const cell04WorkerCode = ` function ranks(values) { const order = Array.from({length: values.length}, (_, i) => i); order.sort((a, b) => values[a] - values[b]); const result = new Float64Array(values.length); for (let start = 0; start < order.length;) { let end = start + 1; while (end < order.length && values[order[end]] === values[order[start]]) end++; const rank = (start + 1 + end) / 2; for (let i = start; i < end; i++) result[order[i]] = rank; start = end; } return result; } function rho(x, y) { if (x.length < 3) return null; const a = ranks(x), b = ranks(y), mean = (x.length + 1) / 2; let cross = 0, ssx = 0, ssy = 0; for (let i = 0; i < x.length; i++) { const dx = a[i] - mean, dy = b[i] - mean; cross += dx * dy; ssx += dx * dx; ssy += dy * dy; } return ssx > 0 && ssy > 0 ? Math.max(-1, Math.min(1, cross / Math.sqrt(ssx * ssy))) : null; } function quantile(sorted, p) { const pos = (sorted.length - 1) * p, lo = Math.floor(pos), fraction = pos - lo; return sorted[lo] + fraction * (sorted[Math.ceil(pos)] - sorted[lo]); } function analyze(rows, seed, repetitions) { const x = rows.map(row => row.distance), y = rows.map(row => row.rating), n = rows.length; const estimate = rho(x, y); if (estimate === null) return {n, estimate, low: null, high: null, valid: 0}; // Mulberry32 gives reproducible paired bootstrap samples. let state = seed >>> 0; function random() { state = (state + 0x6D2B79F5) >>> 0; let t = state; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; } const bx = new Float64Array(n), by = new Float64Array(n), estimates = []; for (let b = 0; b < repetitions; b++) { for (let i = 0; i < n; i++) { const j = Math.floor(random() * n); bx[i] = x[j]; by[i] = y[j]; } const value = rho(bx, by); if (value !== null) estimates.push(value); } estimates.sort((a, b) => a - b); // Do not silently discard degenerate replicates when constructing an interval. const complete = estimates.length === repetitions; return {n, estimate, valid: estimates.length, low: complete ? quantile(estimates, 0.025) : null, high: complete ? quantile(estimates, 0.975) : null}; } self.onmessage = event => { try { const {all, near, far, repetitions} = event.data; self.postMessage({all: analyze(all, 20261102, repetitions), near: analyze(near, 20261104, repetitions), far: analyze(far, 20261103, repetitions)}); } catch (error) { self.postMessage({error: String(error)}); } };`; const cell04Repetitions = 2000; const cell04Url = URL.createObjectURL(new Blob([cell04WorkerCode], {type: "text/javascript"})); const cell04Worker = new Worker(cell04Url); // Clean up when the cell is rerun or removed. invalidation.then(() => { cell04Worker.terminate(); URL.revokeObjectURL(cell04Url); }); cell04Worker.onerror = event => { cell04Results.replaceChildren(cell04Htl.html`

Calculation failed: ${event.message}

`); cell04Worker.terminate(); URL.revokeObjectURL(cell04Url); }; cell04Worker.onmessage = event => { cell04Worker.terminate(); URL.revokeObjectURL(cell04Url); if (event.data.error) { cell04Results.replaceChildren(cell04Htl.html`

Calculation failed: ${event.data.error}

`); return; } const pValue = result => { if (result.estimate === null || result.n < 3) return null; if (result.estimate === 1) return 0; if (result.estimate === -1) return 1; const t = result.estimate * Math.sqrt((result.n - 2) / (1 - result.estimate ** 2)); // By symmetry, the upper tail at t is the lower tail at -t. return cell04JStat.studentt.cdf(-t, result.n - 2); }; const format = value => value === null || !Number.isFinite(value) ? "—" : value.toFixed(4); const pFormat = value => value === null || !Number.isFinite(value) ? "—" : value < 0.0001 ? "< 0.0001" : value.toFixed(4); const interval = result => result.low === null ? "Unavailable" : `[${format(result.low)}, ${format(result.high)}]`; const primary = event.data.all, near = event.data.near, far = event.data.far; const analyses = [primary, near, far]; const rows = [ ["Sample size", ...analyses.map(result => result.n.toLocaleString())], ["Spearman’s rho", ...analyses.map(result => format(result.estimate))], ["One-sided p-value", ...analyses.map(result => pFormat(pValue(result)))], ["95% bootstrap CI", ...analyses.map(interval)] ]; const table = cell04D3.create("table") .style("border-collapse", "collapse") .style("width", "100%") .style("font", "13px system-ui, sans-serif") .style("text-align", "left"); table.append("thead").append("tr").selectAll("th") .data(["Statistic", "0–1,500 m (primary)", "0–<500 m (secondary)", "500–1,500 m (secondary)"]) .join("th").text(d => d) .style("padding", "6px 8px").style("border-bottom", "1px solid #aaa") .style("text-align", "left"); table.append("tbody").selectAll("tr").data(rows).join("tr") .selectAll("td").data(d => d).join("td").text(d => d) .style("padding", "6px 8px").style("border-bottom", "1px solid #ddd") .style("vertical-align", "top"); const degenerate = analyses.some(result => result.estimate !== null && result.valid < cell04Repetitions); cell04Results.replaceChildren( table.node(), cell04Htl.html`

H₁: ratings increase with distance (ρ > 0).`, ...(degenerate ? [cell04Htl.html`

Unavailable interval.

`] : []) ); }; cell04Worker.postMessage({all: cell04Rows, near: cell04Near, far: cell04Far, repetitions: cell04Repetitions}); 50:T1d97,// Cell 05 — paste this entire file into one Observable JavaScript or TypeScript cell. // Attach restaurants_paris.geojson to the notebook before running. import * as cell05Htl from "npm:htl"; // Prepare the data, calculate the JT statistics, and display the results table. // Pure JavaScript: no browser or Node-specific APIs. function createJTCore() { const bands = ["<250m", "<500m", "<750m", "<1000m", "<1250m", "<1500m"]; const expectedCounts = [9, 49, 106, 254, 320, 332]; function prepare(geojson) { if (!Array.isArray(geojson?.features)) throw Error("Expected a GeoJSON FeatureCollection with features."); const rows = [], mismatches = []; let missingDistance = 0, missingRating = 0; for (const feature of geojson.features) { const p = feature.properties ?? {}, d = p.distance_from_eiffeltower_m; if (!Number.isFinite(d) || d < 0) { missingDistance++; continue; } if (d > 1500) continue; if (!Number.isFinite(p.rating)) { missingRating++; continue; } // Use the existing categories; never derive or replace the band from distance. const index = bands.indexOf(p.distance_band); if (index < 0) { mismatches.push({fid: p.fid, distance: d, actual: p.distance_band}); continue; } const lower = index * 250, upper = (index + 1) * 250; if (d < lower || (index === 5 ? d > upper : d >= upper)) mismatches.push({fid: p.fid, distance: d, actual: p.distance_band}); rows.push({id: p.fid, band: index, distanceBand: p.distance_band, rating: p.rating, distance: d}); } const counts = bands.map((_, i) => rows.filter(r => r.band === i).length); return {rows, counts, mismatches, missingDistance, missingRating, countDiscrepancies: counts.map((actual, i) => ({band: bands[i], actual, expected: expectedCounts[i]})).filter(x => x.actual !== x.expected)}; } function pairwise(groups) { let jt = 0; for (let i = 0; i < groups.length; i++) for (let j = i + 1; j < groups.length; j++) for (const a of groups[i]) for (const b of groups[j]) jt += b > a ? 1 : b === a ? 0.5 : 0; return jt; } function makeCalculator(groups) { const values = [...new Set(groups.flat())].sort((a, b) => a - b); const ranks = new Map(values.map((v, i) => [v, i + 1])); const sizes = groups.map(g => g.length); const initial = groups.flat().map(v => ranks.get(v)); function calculate(rankValues) { const tree = new Int32Array(values.length + 1); let jt = 0, previous = 0, start = 0; for (const size of sizes) { for (let i = start; i < start + size; i++) { const rank = rankValues[i]; let less = 0, through = 0; for (let k = rank - 1; k > 0; k -= k & -k) less += tree[k]; for (let k = rank; k > 0; k -= k & -k) through += tree[k]; jt += less + (through - less) / 2; } for (let i = start; i < start + size; i++) for (let k = rankValues[i]; k < tree.length; k += k & -k) tree[k]++; previous += size; start = previous; } return jt; } return {initial, sizes, calculate}; } function rng(seed) { let state = seed >>> 0; return () => { state = (state + 0x6D2B79F5) >>> 0; let t = state; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return (t ^ (t >>> 14)) >>> 0; }; } // Rejection sampling avoids modulo bias in each Fisher–Yates index. function shuffle(a, randomUint32) { for (let i = a.length - 1; i > 0; i--) { const range = i + 1, limit = Math.floor(4294967296 / range) * range; let x; do { x = randomUint32(); } while (x >= limit); const j = x % range; [a[i], a[j]] = [a[j], a[i]]; } return a; } function permutationP(observed, samples) { return (1 + samples.filter(x => x >= observed).length) / (samples.length + 1); } function analyze(groups, seed = 20261102, permutations = 9999) { if (groups.length < 2 || groups.some(g => !g.length)) throw Error("Each ordered analysis requires at least two nonempty groups."); if (!Number.isInteger(permutations) || permutations < 1) throw Error("Permutations must be a positive integer."); const calc = makeCalculator(groups), observed = calc.calculate(calc.initial); let pairs = 0; for (let i = 0; i < calc.sizes.length; i++) for (let j = i + 1; j < calc.sizes.length; j++) pairs += calc.sizes[i] * calc.sizes[j]; const random = rng(seed), ranks = calc.initial.slice(), distribution = []; for (let i = 0; i < permutations; i++) { shuffle(ranks, random); distribution.push(calc.calculate(ranks)); } const p = permutationP(observed, distribution), probability = observed / pairs; return {n: ranks.length, sizes: calc.sizes, observed, expected: pairs / 2, pairs, probability, dominance: 2 * probability - 1, p, permutations, seed, distribution}; } return {bands, expectedCounts, prepare, pairwise, makeCalculator, rng, shuffle, permutationP, analyze}; } const cell05Core = createJTCore(); const cell05Data = cell05Core.prepare(await FileAttachment("restaurants_paris.geojson").json()); const cell05Groups = cell05Core.bands.map((_, i) => cell05Data.rows.filter(r => r.band === i).map(r => r.rating)); const cell05Output = cell05Htl.html`

Running 9,999 permutations for each analysis…

`; display(cell05Output); // Run the expensive permutation calculations in a worker, with fixed seeds. const cell05WorkerSource = `const createJTCore = ${createJTCore.toString()}; self.onmessage = ({data}) => { try { const core = createJTCore(); self.postMessage({full: core.analyze(data, 20261102, 9999), near: core.analyze(data.slice(0, 2), 20261104, 9999), beyond: core.analyze(data.slice(2), 20261103, 9999)}); } catch (error) { self.postMessage({error: String(error)}); } };`; const cell05WorkerUrl = URL.createObjectURL(new Blob([cell05WorkerSource], {type: "text/javascript"})); const cell05Worker = new Worker(cell05WorkerUrl); invalidation.then(() => { cell05Worker.terminate(); URL.revokeObjectURL(cell05WorkerUrl); }); const cell05Results = await new Promise((resolve, reject) => { cell05Worker.onerror = event => reject(new Error(event.message)); cell05Worker.onmessage = ({data}) => data.error ? reject(new Error(data.error)) : resolve(data); cell05Worker.postMessage(cell05Groups); }).finally(() => { cell05Worker.terminate(); URL.revokeObjectURL(cell05WorkerUrl); }); { const fmt = x => Number.isFinite(x) ? x.toFixed(4) : "—"; const full = cell05Results.full, near = cell05Results.near, beyond = cell05Results.beyond; const analyses = [full, near, beyond]; const summaryRows = [["Restaurants", ...analyses.map(r => r.n)], ["JT statistic", ...analyses.map(r => r.observed)], ["Expected JT under random labeling", ...analyses.map(r => r.expected)], ["Cross-band pairs", ...analyses.map(r => r.pairs)], ["P: normalized favorable comparisons", ...analyses.map(r => fmt(r.probability))], ["D: directional dominance", ...analyses.map(r => fmt(r.dominance))], ["One-sided permutation p-value", ...analyses.map(r => fmt(r.p))]]; const table = cell05Htl.html`${summaryRows.map(row => cell05Htl.html`${row.map(v => cell05Htl.html``)}`)}

Statistic	0–1,500 m (primary)	0–<500 m (exploratory)	500–1,500 m (exploratory)
${v}

`; cell05Output.replaceChildren(table); } 51:Tcc7,// Cell 06 — paste this entire file into one Observable JavaScript or TypeScript cell. // Attach restaurants_paris.geojson to the notebook before running it. import * as cell06Htl from "npm:htl"; import * as cell06Plot from "npm:@observablehq/plot"; const cell06Bands = ["<250m", "<500m", "<750m", "<1000m", "<1250m", "<1500m"]; const cell06GeoJSON = await FileAttachment("restaurants_paris.geojson").json(); const cell06Rows = cell06GeoJSON.features.map(feature => feature.properties ?? {}) .filter(row => Number.isFinite(row.rating) && Number.isFinite(row.distance_from_eiffeltower_m) && row.distance_from_eiffeltower_m >= 0 && row.distance_from_eiffeltower_m <= 1500 && cell06Bands.includes(row.distance_band)); // Linearly interpolate between neighboring values in the sorted sample. function cell06Quantile(sorted, probability) { const position = (sorted.length - 1) * probability; const lower = Math.floor(position); return sorted[lower] + (position - lower) * (sorted[Math.ceil(position)] - sorted[lower]); } const cell06Summaries = cell06Bands.map(band => { const ratings = cell06Rows.filter(row => row.distance_band === band) .map(row => row.rating).sort((a, b) => a - b); return { band, n: ratings.length, mean: ratings.length ? ratings.reduce((sum, value) => sum + value, 0) / ratings.length : null, median: ratings.length ? cell06Quantile(ratings, 0.5) : null, q1: ratings.length ? cell06Quantile(ratings, 0.25) : null, q3: ratings.length ? cell06Quantile(ratings, 0.75) : null }; }); const cell06Format = value => Number.isFinite(value) ? value.toFixed(4) : "—"; const cell06Table = cell06Htl.html`${cell06Summaries.map(row => cell06Htl.html`${ [row.band, row.n, cell06Format(row.mean), cell06Format(row.median), cell06Format(row.q1), cell06Format(row.q3)] .map(value => cell06Htl.html``) }`)}

Band	n	Mean	Median	Q1	Q3
${value}

`; display(cell06Table); // Draw the barcode, overlay translucent boxplots, and mark the medians in red. const cell06BoxPlot = cell06Plot.plot({ width: 900, height: 1000, marginLeft: 60, marginBottom: 50, x: {domain: cell06Bands, label: "Distance band (m)"}, y: {domain: [1, 5], inset: 8, label: "Restaurant rating"}, marks: [ cell06Plot.tickY(cell06Rows, { x: "distance_band", y: "rating", stroke: "#356c8d", strokeOpacity: 0.3, title: row => `${row.restaurant_name || "Restaurant"}\nRating: ${row.rating.toFixed(2)}\nDistance: ${Math.round(row.distance_from_eiffeltower_m)} m` }), cell06Plot.boxY(cell06Rows, { x: "distance_band", y: "rating", fill: "#9ecae1", fillOpacity: 0.45, stroke: "#356c8d", r: 0 // Ratings outside the whiskers already appear as barcode ticks. }), cell06Plot.tickY(cell06Summaries.filter(row => row.median !== null), { x: "band", y: "median", stroke: "#c52b2b", strokeWidth: 3, title: row => `Median rating: ${row.median.toFixed(2)}` }) ] }); display(cell06BoxPlot); 52:T2120,// Cell 08 — paste this entire file into one Observable Notebooks 2.0 JS/TS cell. // Attach restaurants_paris.geojson to the notebook before running it. import * as cell08Plot from "npm:@observablehq/plot"; import * as cell08Inputs from "npm:@observablehq/inputs"; // Keep restaurants with an observed rating and distance within 1,500 m. const cell08GeoJSON = await FileAttachment("restaurants_paris.geojson").json(); const cell08Data = cell08GeoJSON.features.map(feature => ({ name: feature.properties?.restaurant_name, rating: feature.properties?.rating, distance: feature.properties?.distance_from_eiffeltower_m })).filter(d => Number.isFinite(d.rating) && Number.isFinite(d.distance) && d.distance >= 0 && d.distance <= 1500); if (cell08Data.length < 30) throw new Error("Not enough restaurants with valid ratings and distances."); const cell08Min = Math.min(...cell08Data.map(d => d.distance)); const cell08Max = Math.max(...cell08Data.map(d => d.distance)); if (!(cell08Max > cell08Min)) throw new Error("The restaurants need more than one distance value."); // Cubic B-spline basis functions allow a smooth, flexible distance curve. // Their coefficients are penalized to discourage unnecessary wiggles. The full // basis already includes an intercept, so a separate intercept is not added. function cell08Fit(cell08Data, cell08BasisCount = 10) { const cell08Min = Math.min(...cell08Data.map(d => d.distance)); const cell08Max = Math.max(...cell08Data.map(d => d.distance)); if (cell08Data.length < 30 || !(cell08Max > cell08Min)) throw new Error("Not enough observations or distance variation for the GAM."); const cell08Knots = [...Array(4).fill(0), ...Array.from({length: cell08BasisCount - 4}, (_, i) => (i + 1) / (cell08BasisCount - 3)), ...Array(4).fill(1)]; function cell08Basis(distance) { if (distance < cell08Min || distance > cell08Max) throw new Error("Distance is outside the observed range."); const x = (distance - cell08Min) / (cell08Max - cell08Min); if (x === 1) return Array.from({length: cell08BasisCount}, (_, i) => +(i === cell08BasisCount - 1)); let basis = Array.from({length: cell08Knots.length - 1}, (_, i) => +(cell08Knots[i] <= x && x < cell08Knots[i + 1])); for (let degree = 1; degree <= 3; degree++) { basis = Array.from({length: cell08Knots.length - degree - 1}, (_, i) => { const leftWidth = cell08Knots[i + degree] - cell08Knots[i]; const rightWidth = cell08Knots[i + degree + 1] - cell08Knots[i + 1]; return (leftWidth ? (x - cell08Knots[i]) / leftWidth * basis[i] : 0) + (rightWidth ? (cell08Knots[i + degree + 1] - x) / rightWidth * basis[i + 1] : 0); }); } return basis; } function cell08Dot(a, b) { return a.reduce((sum, value, i) => sum + value * b[i], 0); } // Solve the small positive-definite system with a Cholesky factorization. function cell08Solve(matrix, rightSide) { const p = rightSide.length; const lower = Array.from({length: p}, () => Array(p).fill(0)); for (let i = 0; i < p; i++) for (let j = 0; j <= i; j++) { let value = matrix[i][j]; for (let k = 0; k < j; k++) value -= lower[i][k] * lower[j][k]; if (i === j) { if (!(value > 1e-12)) throw new Error("The spline model could not be fitted reliably."); lower[i][j] = Math.sqrt(value); } else lower[i][j] = value / lower[j][j]; } const y = Array(p), result = Array(p); for (let i = 0; i < p; i++) { let value = rightSide[i]; for (let j = 0; j < i; j++) value -= lower[i][j] * y[j]; y[i] = value / lower[i][i]; } for (let i = p - 1; i >= 0; i--) { let value = y[i]; for (let j = i + 1; j < p; j++) value -= lower[j][i] * result[j]; result[i] = value / lower[i][i]; } return result; } // Fit each smoothing level, then choose the one with the lowest generalized // cross-validation (GCV) score. EDF summarizes the curve's flexibility. const cell08X = cell08Data.map(d => cell08Basis(d.distance)); const cell08P = cell08X[0].length, cell08N = cell08Data.length; const cell08Cross = Array.from({length: cell08P}, () => Array(cell08P).fill(0)); const cell08Xy = Array(cell08P).fill(0); const cell08Penalty = Array.from({length: cell08P}, () => Array(cell08P).fill(0)); for (let i = 0; i < cell08N; i++) for (let j = 0; j < cell08P; j++) { cell08Xy[j] += cell08X[i][j] * cell08Data[i].rating; for (let k = 0; k < cell08P; k++) cell08Cross[j][k] += cell08X[i][j] * cell08X[i][k]; } // Penalize second differences of the spline coefficients. for (let i = 0; i < cell08BasisCount - 2; i++) for (let j = 0; j < 3; j++) for (let k = 0; k < 3; k++) cell08Penalty[i + j][i + k] += [1, -2, 1][j] * [1, -2, 1][k]; const cell08Mean = cell08Data.reduce((sum, d) => sum + d.rating, 0) / cell08N; const cell08SST = cell08Data.reduce((sum, d) => sum + (d.rating - cell08Mean) ** 2, 0); const cell08Lambdas = Array.from({length: 29}, (_, i) => 10 ** (-4 + i * 0.25)); let cell08Best = null; for (const lambda of cell08Lambdas) { const system = cell08Cross.map((row, i) => row.map((value, j) => value + lambda * cell08Penalty[i][j])); let coefficients, edf; try { coefficients = cell08Solve(system, cell08Xy); edf = cell08Cross.reduce((sum, _, j) => sum + cell08Solve(system, cell08Cross.map(row => row[j]))[j], 0); } catch { continue; } const sse = cell08Data.reduce((sum, d, i) => sum + (d.rating - cell08Dot(cell08X[i], coefficients)) ** 2, 0); const gcv = cell08N * sse / (cell08N - edf) ** 2; if (Number.isFinite(gcv) && (!cell08Best || gcv < cell08Best.gcv)) cell08Best = {lambda, coefficients, edf, sse, gcv}; } if (!cell08Best) throw new Error("No valid GAM fit was found."); const cell08Gam = {...cell08Best, n: cell08N, min: cell08Min, max: cell08Max, mean: cell08Mean, lambdaAtEdge: cell08Best.lambda === cell08Lambdas[0] || cell08Best.lambda === cell08Lambdas[cell08Lambdas.length - 1], rmse: Math.sqrt(cell08Best.sse / cell08N), residualSD: Math.sqrt(cell08Best.sse / (cell08N - cell08Best.edf)), r2: cell08SST > 0 ? 1 - cell08Best.sse / cell08SST : null, predict: distance => cell08Dot(cell08Basis(distance), cell08Best.coefficients) }; return cell08Gam; } const cell08Gam = cell08Fit(cell08Data); const cell08MeanDistance = cell08Data.reduce((sum, row) => sum + row.distance, 0) / cell08Data.length; const cell08Slope = cell08Data.reduce((sum, row) => sum + (row.distance - cell08MeanDistance) * (row.rating - cell08Gam.mean), 0) / cell08Data.reduce((sum, row) => sum + (row.distance - cell08MeanDistance) ** 2, 0); const cell08Predictions = Array.from({length: 201}, (_, i) => { const distance = i === 200 ? cell08Max : cell08Min + (cell08Max - cell08Min) * i / 200; return {distance, gam: cell08Gam.predict(distance), linear: cell08Gam.mean + cell08Slope * (distance - cell08MeanDistance)}; }); const cell08Results = [ {metric: "Restaurants", value: cell08Gam.n}, {metric: "Mean rating", value: cell08Gam.mean}, {metric: "R²", value: cell08Gam.r2}, {metric: "RMSE (in sample)", value: cell08Gam.rmse}, {metric: "Residual standard deviation (approx.)", value: cell08Gam.residualSD}, {metric: "Effective degrees of freedom (EDF)", value: cell08Gam.edf}, {metric: "GCV score", value: cell08Gam.gcv}, {metric: "Smoothing penalty (λ)", value: cell08Gam.lambda} ]; const cell08Format = value => value == null ? "—" : Number.isInteger(value) ? value.toLocaleString() : value.toFixed(4); display(cell08Inputs.table(cell08Results, {rows: cell08Results.length, header: {metric: "GAM metric", value: "Value"}, format: {value: cell08Format}})); display(cell08Plot.plot({ title: "Restaurant ratings versus distance from the Eiffel Tower", width: 900, height: 500, x: {label: "Distance from Eiffel Tower (m)", domain: [cell08Min, cell08Max]}, y: {label: "Restaurant rating", domain: [1, 5]}, color: {legend: true, domain: ["GAM", "Linear reference"], range: ["#14532d", "#86b86c"]}, marks: [ cell08Plot.ruleX([500], {stroke: "#888", strokeDasharray: "4,4"}), cell08Plot.dot(cell08Data, {x: "distance", y: "rating", r: 2, fill: "#374151", fillOpacity: 0.55, title: d => `${d.name || "Restaurant"}\nRating: ${d.rating}\nDistance: ${Math.round(d.distance)} m`}), cell08Plot.line(cell08Predictions, {x: "distance", y: "gam", stroke: () => "GAM", strokeWidth: 3, clip: true}), cell08Plot.line(cell08Predictions, {x: "distance", y: "linear", stroke: () => "Linear reference", strokeWidth: 2.5, strokeDasharray: "10,6", clip: true}) ] })); 53:T2851,// CELL 09.1 — Data preparation. Paste this section into its own Observable JS/TS cell. // Attach restaurants_paris.geojson to the notebook before running this cell. import * as cell09Plot from "npm:@observablehq/plot"; import * as cell09Inputs from "npm:@observablehq/inputs"; import {html as cell09Html} from "npm:htl"; // To run a separate sensitivity scan, set this to a positive integer below 20. // Keep the primary minimum at 20 for the prespecified primary analysis. const cell09Minimum = 20; const cell09SensitivityMinimum = null; // Example: 9. Null disables the extra scan. const cell09Permutations = 9999; const cell09Seed = 20261102; const cell09GeoJSON = await FileAttachment("restaurants_paris.geojson").json(); const permutationData = cell09GeoJSON.features.map(({properties: p}) => ({ rating: p?.rating, distance: p?.distance_from_eiffeltower_m })).filter(d => Number.isFinite(d.rating) && d.rating >= 1 && d.rating <= 5 && Number.isFinite(d.distance) && d.distance >= 0 && d.distance <= 1500) .sort ( (a, b) => a.distance - b.distance ); if (!Number.isInteger(cell09Minimum) || cell09Minimum < 1) throw new Error("Minimum group size must be a positive integer."); if (cell09SensitivityMinimum !== null && (!Number.isInteger(cell09SensitivityMinimum) || cell09SensitivityMinimum < 1 || cell09SensitivityMinimum >= cell09Minimum)) throw new Error("Sensitivity minimum must be a positive integer smaller than the primary minimum, or null."); // Include 0 and 1,500 in the grid; empty groups are always ineligible. const cell09Grid = Array.from({length: 61}, (_, i) => i * 25); let cell09Count = 0; const cell09Thresholds = cell09Grid.map(radius => { while (cell09Count < permutationData.length && permutationData[cell09Count].distance <= radius) cell09Count++; return {radius, n_inside: cell09Count, n_outside: permutationData.length - cell09Count}; }); const cell09Eligible = cell09Thresholds.filter(d => d.n_inside >= cell09Minimum && d.n_outside >= cell09Minimum); if (!cell09Eligible.length) throw new Error("No radii satisfy the minimum group size; check the data or minimum."); if (cell09Minimum < 20) display(cell09Html`

Warning: A minimum below 20 can produce unstable estimates; treat this scan as exploratory.

`); // CELL 09.2 — Permutation functions. Paste this section into a second cell. // A fixed-seed generator and Fisher–Yates shuffle randomize ratings, never distances. function cell09Random(seed) { let state = seed >>> 0; return () => { state = (state + 0x6D2B79F5) >>> 0; let t = state; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; } function cell09Shuffle(values, random) { for (let i = values.length - 1; i > 0; i--) { const j = Math.floor(random() * (i + 1)); [values[i], values[j]] = [values[j], values[i]]; } } // Cumulative sums evaluate all sorted thresholds in one pass per arrangement. function cell09Differences(ratings, thresholds, total) { const n = ratings.length, differences = new Float64Array(thresholds.length); let sum = 0, index = 0; for (let j = 0; j < thresholds.length; j++) { const inside = thresholds[j].n_inside; while (index < inside) sum += ratings[index++]; differences[j] = (total - sum) / (n - inside) - sum / inside; } return differences; } function cell09Analyze(data, thresholds, iterations, seed) { if (!thresholds.length) throw new Error("The scan has no eligible radii."); if (!Number.isInteger(iterations) || iterations < 2) throw new Error("At least two permutations are required."); const n = data.length, k = thresholds.length; const original = data.map(d => d.rating); const total = original.reduce((a, b) => a + b, 0); const observed = cell09Differences(original, thresholds, total); const means = new Float64Array(k), m2 = new Float64Array(k); // Store the complete simulated curve for each common shuffled arrangement. const curves = new Float64Array(iterations * k); const shuffled = original.slice(), random = cell09Random(seed); for (let b = 0; b < iterations; b++) { cell09Shuffle(shuffled, random); const values = cell09Differences(shuffled, thresholds, total); for (let j = 0; j < k; j++) { const value = values[j]; curves[b * k + j] = value; const delta = value - means[j]; means[j] += delta / (b + 1); m2[j] += delta * (value - means[j]); } } const sds = Array.from(m2, value => Math.sqrt(Math.max(0, value / (iterations - 1)))); // Numerically constant null distributions contribute zero, rather than NaN. // The observed assignment belongs to the same permutation space. const z = (value, j) => sds[j] <= 1e-12 ? 0 : (value - means[j]) / sds[j]; const observedZ = Array.from(observed, (value, j) => z(value, j)); const maxima = new Float64Array(iterations); for (let b = 0; b < iterations; b++) { let max = -Infinity; for (let j = 0; j < k; j++) max = Math.max(max, z(curves[b * k + j], j)); maxima[b] = max; } const maxZ = Math.max(...observedZ); let exceedances = 0; for (const maximum of maxima) if (maximum >= maxZ) exceedances++; const globalP = (1 + exceedances) / (iterations + 1); // Monte Carlo critical rank: ceil((B + 1) * 0.95), using one-based indexing. // A strict exceedance is conservative when the permutation maxima have ties. const sortedMaxima = Array.from(maxima).sort((a, b) => a - b); const criticalIndex = Math.ceil((iterations + 1) * 0.95) - 1; const critical = criticalIndex < iterations ? sortedMaxima[criticalIndex] : Infinity; let insideSum = 0, index = 0; const rows = thresholds.map((threshold, j) => { while (index < threshold.n_inside) insideSum += original[index++]; const meanInside = insideSum / threshold.n_inside; const meanOutside = (total - insideSum) / threshold.n_outside; const upper = means[j] + critical * sds[j]; return {...threshold, mean_inside: meanInside, mean_outside: meanOutside, observed_difference: observed[j], permutation_mean: means[j], permutation_sd: sds[j], standardized_difference: observedZ[j], upper_envelope: upper, significant: observedZ[j] > critical}; }); const maxStandardized = rows.reduce((best, row) => row.standardized_difference > best.standardized_difference ? row : best); const maxRaw = rows.reduce((best, row) => row.observed_difference > best.observed_difference ? row : best); return {rows, globalP, maxZ, maxStandardized, maxRaw, critical, iterations, seed, curves, maxima}; } function cell09Describe(data, radius) { const inside = data.filter(d => d.distance <= radius), outside = data.filter(d => d.distance > radius); const mean = group => group.length ? group.reduce((sum, d) => sum + d.rating, 0) / group.length : null; const a = mean(inside), b = mean(outside); return {radius, n_inside: inside.length, n_outside: outside.length, mean_inside: a, mean_outside: b, observed_difference: a === null || b === null ? null : b - a}; } // CELL 09.3 — Run the analysis. Paste this section into a third cell. // Each scan uses one common shuffled rating arrangement across all its radii. const cell09Result = cell09Analyze(permutationData, cell09Eligible, cell09Permutations, cell09Seed); const cell09Rows = cell09Result.rows; const cell09At250 = cell09Describe(permutationData, 250); const cell09SensitivityEligible = cell09SensitivityMinimum === null ? [] : cell09Thresholds.filter(d => d.n_inside >= cell09SensitivityMinimum && d.n_outside >= cell09SensitivityMinimum); const cell09Sensitivity = cell09SensitivityMinimum === null ? null : cell09Analyze(permutationData, cell09SensitivityEligible, cell09Permutations, cell09Seed); if (cell09Sensitivity) display(cell09Html`

Sensitivity scan: minimum ${cell09SensitivityMinimum} per group, ${cell09Sensitivity.rows[0].radius}–${cell09Sensitivity.rows.at(-1).radius} m; separately corrected global p = ${cell09Sensitivity.globalP.toFixed(4)}; maximum standardized difference at ${cell09Sensitivity.maxStandardized.radius} m; largest raw difference at ${cell09Sensitivity.maxRaw.radius} m. Radii above its own simultaneous envelope: ${cell09Sensitivity.rows.filter(d => d.significant).map(d => `${d.radius} m`).join(", ") || "none"}. Small groups can make estimates unstable. This is a separate exploratory analysis.

`); // CELL 09.4 — Main plot. Paste this section into a fourth cell. display(cell09Plot.plot({ title: "Cumulative restaurant rating difference by radius", subtitle: "Outside minus inside; upper line is the one-sided simultaneous 95% envelope", width: 900, height: 500, x: {label: "Radius from Eiffel Tower (m)", domain: [0, 1500]}, y: {label: "Mean rating difference (outside − inside)"}, color: {legend: true, domain: ["Observed difference", "Simultaneous upper envelope", "Above envelope"], range: ["#4b2c20", "#e87500", "#670d2f"]}, marks: [ cell09Plot.ruleY([0], {stroke: "#777"}), cell09Plot.ruleX([250, 500, 750, 1000, 1250, 1500], {stroke: "#999", strokeDasharray: "1,4", strokeLinecap: "round"}), cell09Plot.line(cell09Rows, {x: "radius", y: "observed_difference", stroke: () => "Observed difference", strokeWidth: 2.5}), cell09Plot.line(cell09Rows, {x: "radius", y: "upper_envelope", stroke: () => "Simultaneous upper envelope", strokeWidth: 2}), cell09Plot.dot(cell09Rows.filter(d => d.significant), {x: "radius", y: "observed_difference", fill: () => "Above envelope", symbol: "times", r: 5, title: d => `${d.radius} m: difference ${d.observed_difference.toFixed(3)}`}) ] })); // CELL 09.5 — Results table. Paste this section into a fifth cell. const cell09Number = value => value == null ? "—" : value.toFixed(3); display(cell09Inputs.table(cell09Rows, { rows: cell09Rows.length, columns: ["radius", "n_inside", "n_outside", "mean_inside", "mean_outside", "observed_difference", "significant"], header: {radius: "Radius (m)", n_inside: "N inside", n_outside: "N outside", mean_inside: "Mean inside", mean_outside: "Mean outside", observed_difference: "Difference", significant: "Significant?"}, format: {mean_inside: cell09Number, mean_outside: cell09Number, observed_difference: cell09Number, significant: d => d ? "Yes" : "No"} })); 54:T6d4,250 m, descriptive only: 9 inside and 1061 outside; mean inside 2.862, mean outside 4.123, difference 1.261. It is excluded from the primary inferential scan because a group is too small. Evidence: The global test finds evidence of a positive outside-minus-inside difference at one or more eligible radii. Global p = 0.0075. Largest differences: The maximum standardized difference is at 350 m (Z = 3.478); the largest raw difference is 0.505 rating points at 350 m. Neither radius establishes a true boundary, and the first eligible radius does not establish where an effect begins. Simultaneous envelope: Radii above the envelope: 325 m, 350 m, 375 m, 425 m, 450 m, 475 m. At or below 500 m, 6 of 8 tested radii exceed it; above 500 m, 0 of 39 tested radii exceed it. The significant-radius pattern is consistent with a disadvantage concentrated near 500 m, but does not establish a boundary. These cumulative comparisons overlap, and a nonsignificant result beyond 500 m does not show that an effect has disappeared. Shape: The observed difference is 0.496 at 325 m and 0.024 at 1475 m; across adjacent eligible radii it decreases 26 times and increases 20 times. A declining cumulative difference does not establish that the underlying distance–rating relationship becomes flat; the separate GAM addresses that continuous shape. Limitations: Group sizes vary, the innermost area is sparse, and cumulative comparisons share observations. The maximum-statistic procedure accounts for the search across eligible radii. Permuting ratings assumes exchangeability across locations; spatial autocorrelation and differences in restaurant characteristics may undermine it. Association does not establish that proximity causes poorer food quality.55:T73c3,// Cell 10 — paste this entire file into one Observable JavaScript or TypeScript cell. // Attach restaurants_paris.geojson, basemap_paris_AOI.geojson, AOI.geojson, // and eiffel_buffers.geojson before running. All four use EPSG:2154. import * as cell10Plot from "npm:@observablehq/plot"; import * as cell10Htl from "npm:htl"; import * as cell10D3 from "npm:d3"; // EDIT THE TITLE AND SUBTITLE HERE. const cell10Title = "The Eiffel-proximate Tourist Trap Effect"; const cell10Subtitle = "Weighted-Rating Distance Decay"; // Didot is used when available; the remaining fonts are local fallbacks. const cell10Font = 'Didot, "Bodoni MT", Georgia, serif'; // EDIT THESE COLORS: keys match the basemap's source attribute exactly. const cell10BasemapColors = { "Parcs": "#F0F4F2", "La Seine": "#F6F8FA", "Tour Eiffel": "#563B22", "batiments": "#F5F5F5" }; const cell10Background = "#ffffff"; const cell10UnknownSourceColor = "#eeeeee"; const cell10MissingRatingColor = "#929292"; const cell10VignetteStartMeters = 1500; // Fade starts at the outer buffer. const cell10VignetteStrength = 1; // White opacity at the farthest map corner, from 0 to 1. const cell10RingDashLength = 5; const cell10RingDashGap = 7; const cell10RingOpacity = 0.67; // 33% transparent. // Both restaurant points and band outlines use this same 1–5 rating scale. const cell10RatingScale = { type: "linear", domain: [1, 1.5, 2.5, 3.5, 4.5, 5], range: ["#a50026", "#a50026", "#f6a09a", "#a6cee3", "#08306b", "#08306b"], interpolate: "rgb", clamp: true, label: "Restaurant rating / median rating in band" }; const [cell10Restaurants, cell10Basemap, cell10AOI, cell10Buffers] = await Promise.all([ FileAttachment("restaurants_paris.geojson").json(), FileAttachment("basemap_paris_AOI.geojson").json(), FileAttachment("AOI.geojson").json(), FileAttachment("eiffel_buffers.geojson").json() ]); for (const [name, data] of Object.entries({ restaurants: cell10Restaurants, basemap: cell10Basemap, AOI: cell10AOI, buffers: cell10Buffers })) { if (data?.type !== "FeatureCollection" || !Array.isArray(data.features)) throw new Error(`${name} must be a GeoJSON FeatureCollection.`); } // Points use the precomputed Lambert-93 distance from the Eiffel Tower. const cell10Points = cell10Restaurants.features.flatMap(feature => { const p = feature.properties ?? {}; const xy = feature.geometry?.coordinates; const distance = p.distance_from_eiffeltower_m; if (feature.geometry?.type !== "Point" || !Array.isArray(xy) || !Number.isFinite(xy[0]) || !Number.isFinite(xy[1]) || !Number.isFinite(distance) || distance < 0 || distance > 1500) return []; const rating = Number.isFinite(p.rating) && p.rating >= 1 && p.rating <= 5 ? p.rating : null; return [{x: xy[0], y: xy[1], distance, rating, name: p.restaurant_name || "Unnamed restaurant"}]; }); // Each outline represents only its own 250 m annulus, not the cumulative circle. // Bands include the lower edge and exclude the upper edge, except 1500 m is included. const cell10Bands = [250, 500, 750, 1000, 1250, 1500].map(radius => { const lower = radius - 250; const ratings = cell10Points.filter(p => p.rating !== null && p.distance >= lower && (radius === 1500 ? p.distance <= radius : p.distance < radius)).map(p => p.rating); return {lower, radius, n: ratings.length, mean: ratings.length ? ratings.reduce((sum, rating) => sum + rating, 0) / ratings.length : null, median: ratings.length ? cell10D3.median(ratings) : null}; }); const cell10BufferFeatures = cell10Buffers.features.map(feature => { const match = /^buffer_(\d+)m$/.exec(feature.properties?.layer ?? ""); const band = cell10Bands.find(d => d.radius === Number(match?.[1])); if (!band) throw new Error(`Unrecognized buffer layer: ${feature.properties?.layer}`); return {...feature, properties: {...feature.properties, ...band}}; }); if (cell10BufferFeatures.length !== cell10Bands.length || new Set(cell10BufferFeatures.map(f => f.properties.radius)).size !== cell10Bands.length) throw new Error("Expected one buffer for each radius from 250 to 1500 m."); // Find the southeast vertex of each supplied ring; north is positive y in EPSG:2154. // This uses the actual buffer geometry and needs no additional tower-point attachment. const cell10RingLabels = cell10BufferFeatures.map(feature => { const ring = feature.geometry.coordinates[0][0]; const centerX = (Math.min(...ring.map(p => p[0])) + Math.max(...ring.map(p => p[0]))) / 2; const centerY = (Math.min(...ring.map(p => p[1])) + Math.max(...ring.map(p => p[1]))) / 2; const [x, y] = ring.reduce((best, p) => (p[0] - centerX) - (p[1] - centerY) > (best[0] - centerX) - (best[1] - centerY) ? p : best); return {...feature.properties, x, y, label: feature.properties.median === null ? "—" : feature.properties.median.toFixed(3)}; }); const cell10MapWidth = Math.max(240, Math.min(width, 1100)); const cell10MapHeight = Math.round(cell10MapWidth * 0.86); // Fit an explicit planar projection to the AOI, with north up and an 8 px margin. // Reuse this exact projection for the scale bar below. const cell10Projection = cell10D3.geoIdentity().reflectY(true) .fitExtent([[8, 8], [cell10MapWidth - 8, cell10MapHeight - 8]], cell10AOI); // Center the fade on the buffer geometry and size it in the projected map's pixels. const cell10CenterRing = cell10BufferFeatures[0].geometry.coordinates[0][0]; const cell10Center = [ (Math.min(...cell10CenterRing.map(p => p[0])) + Math.max(...cell10CenterRing.map(p => p[0]))) / 2, (Math.min(...cell10CenterRing.map(p => p[1])) + Math.max(...cell10CenterRing.map(p => p[1]))) / 2 ]; const [cell10VignetteX, cell10VignetteY] = cell10Projection(cell10Center); const cell10FadeStartPoint = cell10Projection([cell10Center[0] + cell10VignetteStartMeters, cell10Center[1]]); const cell10FadeStart = Math.hypot(cell10FadeStartPoint[0] - cell10VignetteX, cell10FadeStartPoint[1] - cell10VignetteY); const cell10FadeRadius = Math.max(...[[0, 0], [cell10MapWidth, 0], [0, cell10MapHeight], [cell10MapWidth, cell10MapHeight]] .map(([x, y]) => Math.hypot(x - cell10VignetteX, y - cell10VignetteY))); const cell10FadeOffset = Math.min(100, 100 * cell10FadeStart / cell10FadeRadius); const cell10FadeId = `cell10-fade-${Math.random().toString(36).slice(2)}`; // Draw buildings first and the tower last, regardless of feature order in the file. const cell10Sources = [...new Set(cell10Basemap.features.map(f => f.properties?.source))]; const cell10SourceOrder = ["batiments", ...cell10Sources.filter(source => !["batiments", "Parcs", "La Seine", "Tour Eiffel"].includes(source)), "Parcs", "La Seine", "Tour Eiffel"].filter(source => cell10Sources.includes(source)); const cell10Map = cell10Plot.plot({ width: cell10MapWidth, height: cell10MapHeight, margin: 8, projection: cell10Projection, color: cell10RatingScale, style: {background: cell10Background, color: "#1f2933", fontFamily: cell10Font}, marks: [ // Separate marks make every source color a literal, independent of the rating scale. ...cell10SourceOrder.map(source => cell10Plot.geo(cell10Basemap.features.filter(f => f.properties?.source === source), { fill: cell10BasemapColors[source] ?? cell10UnknownSourceColor, stroke: "none" })), // The fade is above the basemap but below all circles, points, and labels. () => cell10Htl.svg` `, cell10Plot.geo(cell10BufferFeatures.filter(f => f.properties.median !== null), { fill: "none", stroke: f => f.properties.median, strokeWidth: 2, strokeDasharray: `${cell10RingDashLength},${cell10RingDashGap}`, strokeOpacity: cell10RingOpacity, strokeLinecap: "round", title: f => `${f.properties.lower}–${f.properties.radius} m band\nMedian rating: ${f.properties.median.toFixed(3)} / 5\nRated restaurants: ${f.properties.n}` }), cell10Plot.geo(cell10BufferFeatures.filter(f => f.properties.median === null), { fill: "none", stroke: cell10MissingRatingColor, strokeWidth: 2, strokeDasharray: `${cell10RingDashLength},${cell10RingDashGap}`, strokeOpacity: cell10RingOpacity, strokeLinecap: "round", title: f => `${f.properties.lower}–${f.properties.radius} m band\nNo rated restaurants` }), cell10Plot.dot(cell10Points.filter(p => p.rating === null), { x: "x", y: "y", r: 3 * 96 / 72, fill: cell10MissingRatingColor, stroke: "none", title: p => `${p.name}\nNo rating\nDistance: ${Math.round(p.distance)} m` }), // SVG paints later points on top: draw high-rated blue before low-rated red. cell10Plot.dot(cell10Points.filter(p => p.rating !== null).sort((a, b) => b.rating - a.rating), { x: "x", y: "y", r: 3 * 96 / 72, fill: "rating", stroke: "none", title: p => `${p.name}\nRating: ${p.rating.toFixed(2)} / 5\nDistance: ${Math.round(p.distance)} m` }), // Labels and outlines use the same band median and shared rating scale. cell10Plot.text(cell10RingLabels.filter(d => d.median !== null), { x: "x", y: "y", text: "label", fill: "median", stroke: "white", strokeWidth: 3, paintOrder: "stroke", fontFamily: cell10Font, fontSize: 11, fontWeight: 600, title: d => `${d.lower}–${d.radius} m band\nMedian rating: ${d.label} / 5\nRated restaurants: ${d.n}` }), cell10Plot.text(cell10RingLabels.filter(d => d.median === null), { x: "x", y: "y", text: "label", fill: cell10MissingRatingColor, stroke: "white", strokeWidth: 3, paintOrder: "stroke", fontFamily: cell10Font, fontSize: 11, fontWeight: 600, title: d => `${d.lower}–${d.radius} m band\nNo rated restaurants` }) ] }); // Measure 500 projected metres in SVG pixels so the bar stays correct when resized. const cell10ScaleStart = cell10Projection([648000, 6862000]); const cell10ScaleEnd = cell10Projection([648500, 6862000]); const cell10ScaleLength = Math.hypot(cell10ScaleEnd[0] - cell10ScaleStart[0], cell10ScaleEnd[1] - cell10ScaleStart[1]); // Center the scale and its headings together, with room for the CRS text. const cell10ScaleCenterX = Math.max(90, 18 + cell10ScaleLength / 2); const cell10ScaleX = cell10ScaleCenterX - cell10ScaleLength / 2; const cell10ScaleY = cell10MapHeight - 27; // These decorations use SVG coordinates; their positions scale with the map. cell10Map.append(cell10Htl.svg` RGF93 / Lambert-93 · EPSG:2154 Scale 1:10,000 0 500 m `); const cell10Legend = cell10Plot.legend({ color: {...cell10RatingScale, label: "TripAdvisor Mean Rating"}, width: Math.min(cell10MapWidth - 80, 140), height: 46, marginLeft: 8, marginRight: 8, ticks: [1, 5], tickFormat: ".0f", style: {fontFamily: cell10Font} }); // Keep legend text readable over the map without an opaque panel. cell10Legend.querySelectorAll("text").forEach(text => { text.setAttribute("stroke", "white"); text.setAttribute("stroke-width", "3"); text.setAttribute("stroke-linejoin", "round"); text.setAttribute("paint-order", "stroke"); }); // A dashed gradient echoes the ring outlines and shares the point rating scale. const cell10MedianLegendWidth = Math.min(cell10MapWidth - 80, 140); const cell10MedianLegendColor = cell10D3.scaleLinear().domain(cell10RatingScale.domain) .range(cell10RatingScale.range).interpolate(cell10D3.interpolateRgb).clamp(true); const cell10MedianLegendSpan = cell10MedianLegendWidth - 16; // Give each dash a literal color, avoiding SVG gradient references on a zero-height line. const cell10MedianLegendStep = cell10RingDashLength + cell10RingDashGap; const cell10MedianLegendDashes = Array.from({length: Math.ceil(cell10MedianLegendSpan / cell10MedianLegendStep)}, (_, i) => { const start = i * cell10MedianLegendStep; const end = Math.min(start + cell10RingDashLength, cell10MedianLegendSpan); const rating = 1 + 4 * (start + end) / (2 * cell10MedianLegendSpan); return {x1: 8 + start, x2: 8 + end, color: cell10MedianLegendColor(rating)}; }); const cell10MedianLegend = cell10Htl.svg``; // Overview uses the full Paris point dataset from Cell 02 with a muted color scale. // The actual AOI geometry, rather than an approximated square, is outlined in brown. const cell10InsetRatingScale = { type: "linear", domain: [1, 5], range: ["#c2c2c2", "#666666"], interpolate: "rgb", clamp: true }; const cell10InsetPoints = cell10Restaurants.features.flatMap(feature => { const xy = feature.geometry?.coordinates; if (feature.geometry?.type !== "Point" || !Array.isArray(xy) || !Number.isFinite(xy[0]) || !Number.isFinite(xy[1])) return []; const rating = feature.properties?.rating; return [{x: xy[0], y: xy[1], rating: Number.isFinite(rating) && rating >= 1 && rating <= 5 ? rating : null}]; }); const cell10InsetWidth = Math.round(0.75 * Math.min(190, Math.max(70, Math.round(cell10MapWidth * 0.22)))); const cell10InsetAOIColor = "#bd8b63"; const cell10Inset = cell10Plot.plot({ width: cell10InsetWidth, height: Math.round(cell10InsetWidth * 0.83), margin: 4, projection: {type: "reflect-y", domain: {type: "MultiPoint", coordinates: cell10InsetPoints.map(p => [p.x, p.y])}}, color: cell10InsetRatingScale, style: {background: "transparent", fontFamily: cell10Font}, marks: [ cell10Plot.dot(cell10InsetPoints.filter(p => p.rating === null), { x: "x", y: "y", r: 0.85, fill: cell10MissingRatingColor, stroke: "none" }), cell10Plot.dot(cell10InsetPoints.filter(p => p.rating !== null).sort((a, b) => b.rating - a.rating), { x: "x", y: "y", r: 0.85, fill: "rating", stroke: "none" }), cell10Plot.geo(cell10AOI, {fill: "none", stroke: cell10InsetAOIColor, strokeWidth: 3}) ] }); // Self-contained version of Cell 07's unadjusted GAM and sensitivity fits. const cell10GamRows = cell10Restaurants.features.map(f => ({...f.properties, rating: f.properties?.rating, distance: f.properties?.distance_from_eiffeltower_m })).filter(d => Number.isFinite(d.rating) && Number.isFinite(d.distance) && d.distance >= 0 && d.distance <= 1500); if (cell10GamRows.length < 30) throw new Error("Too few ratings and distances for the GAM."); const cell10GamMin = Math.min(...cell10GamRows.map(d => d.distance)); const cell10GamMax = Math.max(...cell10GamRows.map(d => d.distance)); function cell10GamSpec(k, min = cell10GamMin, max = cell10GamMax) { const degree = 3, interior = k - degree - 1; if (k < 4 || !(max > min)) throw new Error("Invalid spline specification."); return {k, min, max, knots: [...Array(4).fill(0), ...Array.from({length: interior}, (_, i) => (i + 1) / (interior + 1)), ...Array(4).fill(1)]}; } function cell10GamBasis(distance, spec) { if (distance < spec.min - 1e-9 || distance > spec.max + 1e-9) throw new Error("Prediction outside observed range."); const x = Math.max(0, Math.min(1, (distance - spec.min) / (spec.max - spec.min))); if (x === 1) return Array.from({length: spec.k}, (_, i) => +(i === spec.k - 1)); const t = spec.knots; let b = Array.from({length: t.length - 1}, (_, i) => +(t[i] <= x && x < t[i + 1])); for (let p = 1; p <= 3; p++) b = Array.from({length: t.length - p - 1}, (_, i) => (t[i + p] > t[i] ? (x - t[i]) / (t[i + p] - t[i]) * b[i] : 0) + (t[i + p + 1] > t[i + 1] ? (t[i + p + 1] - x) / (t[i + p + 1] - t[i + 1]) * b[i + 1] : 0)); return b; } function cell10GamPenalty(k, p) { const s = Array.from({length: p}, () => Array(p).fill(0)); for (let i = 0; i < k - 2; i++) for (let a = 0; a < 3; a++) for (let b = 0; b < 3; b++) s[i + a][i + b] += [1, -2, 1][a] * [1, -2, 1][b]; return s; } // Cholesky factorization solves the small positive-definite penalized system; // fail explicitly on rank deficiency instead of quietly adding a ridge penalty. function cell10GamCholesky(a) { const n = a.length, l = Array.from({length: n}, () => Array(n).fill(0)); for (let i = 0; i < n; i++) for (let j = 0; j <= i; j++) { let v = a[i][j]; for (let k = 0; k < j; k++) v -= l[i][k] * l[j][k]; if (i === j) { if (!(v > 1e-12)) throw new Error("Rank-deficient model matrix."); l[i][j] = Math.sqrt(v); } else l[i][j] = v / l[j][j]; } return l; } function cell10GamSolve(l, b) { const n = b.length, y = Array(n), x = Array(n); for (let i = 0; i < n; i++) { let v = b[i]; for (let j = 0; j < i; j++) v -= l[i][j] * y[j]; y[i] = v / l[i][i]; } for (let i = n - 1; i >= 0; i--) { let v = y[i]; for (let j = i + 1; j < n; j++) v -= l[j][i] * x[j]; x[i] = v / l[i][i]; } return x; } const cell10GamDot = (a, b) => a.reduce((s, x, i) => s + x * b[i], 0); const cell10GamLambdas = Array.from({length: 29}, (_, i) => 10 ** (-4 + i * 0.25)); function cell10GamFit(rows, spec, controls = () => [], lambdas = cell10GamLambdas) { const x = rows.map(d => [...cell10GamBasis(d.distance, spec), ...controls(d)]), y = rows.map(d => d.rating); const n = x.length, p = x[0].length; if (n <= p) throw new Error("Not enough observations for the model."); const cross = Array.from({length: p}, () => Array(p).fill(0)), xy = Array(p).fill(0); let yy = 0; for (let r = 0; r < n; r++) { yy += y[r] ** 2; for (let i = 0; i < p; i++) { xy[i] += x[r][i] * y[r]; for (let j = 0; j <= i; j++) cross[i][j] += x[r][i] * x[r][j]; }} for (let i = 0; i < p; i++) for (let j = 0; j < i; j++) cross[j][i] = cross[i][j]; const penalty = cell10GamPenalty(spec.k, p); let best = null; const smoothingScores = []; for (const lambda of lambdas) { let l; try { l = cell10GamCholesky(cross.map((row, i) => row.map((v, j) => v + lambda * penalty[i][j]))); } catch { continue; } const beta = cell10GamSolve(l, xy); let edf = 0; for (let j = 0; j < p; j++) edf += cell10GamSolve(l, cross.map(row => row[j]))[j]; // Algebraic SSE avoids repeated passes over observations for each lambda. const sse = Math.max(0, yy - 2 * cell10GamDot(beta, xy) + cell10GamDot(beta, cross.map(row => cell10GamDot(row, beta)))); const gcv = n * sse / (n - edf) ** 2; if (Number.isFinite(gcv)) smoothingScores.push({lambda, gcv}); if (Number.isFinite(gcv) && (!best || gcv < best.gcv)) best = {beta, edf, sse, gcv, lambda}; } if (!best) throw new Error("No numerically valid fit; inspect the model matrix."); const mean = y.reduce((a, b) => a + b, 0) / n, sst = y.reduce((a, b) => a + (b - mean) ** 2, 0); const predict = (distance, controlVector = Array(p - spec.k).fill(0)) => cell10GamDot([...cell10GamBasis(distance, spec), ...controlVector], best.beta); const fitted = x.map(row => cell10GamDot(row, best.beta)); return {...best, n, spec, fitted, smoothingScores, residuals: y.map((v, i) => v - fitted[i]), predict, rmse: Math.sqrt(best.sse / n), residualSD: Math.sqrt(best.sse / (n - best.edf)), r2: sst > 0 ? 1 - best.sse / sst : null}; } const cell10GamSpec10 = cell10GamSpec(10); const cell10GamPrimary = cell10GamFit(cell10GamRows, cell10GamSpec10); const cell10GamLeaveOneOut = cell10GamRows.filter(row => row.distance < 250).map(row => { const sample = cell10GamRows.filter(d => d !== row); return {fit: cell10GamFit(sample, cell10GamSpec10), min: Math.min(...sample.map(d => d.distance)), max: Math.max(...sample.map(d => d.distance))}; }); const cell10GamReviewSample = cell10GamRows.filter(row => Number.isFinite(row.reviews_count_in_default_language) && row.reviews_count_in_default_language >= 5); const cell10GamReviewFit = cell10GamReviewSample.length > 30 ? cell10GamFit(cell10GamReviewSample, cell10GamSpec10) : null; const cell10GamReviewMin = cell10GamReviewFit ? Math.min(...cell10GamReviewSample.map(d => d.distance)) : null; const cell10GamReviewMax = cell10GamReviewFit ? Math.max(...cell10GamReviewSample.map(d => d.distance)) : null; const cell10GamGrid = Array.from({length: 201}, (_, i) => i === 200 ? cell10GamMax : cell10GamMin + (cell10GamMax - cell10GamMin) * i / 200); const cell10GamCurve = (fit, min, max) => cell10GamGrid.filter(distance => distance >= min && distance <= max) .map(distance => ({distance, predicted: fit.predict(distance)})); const cell10GamOriginalWidth = Math.min(290, Math.max(170, Math.round(cell10MapWidth * 0.35)), cell10MapWidth - 24); const cell10GamWidth = Math.round(1.25 * Math.round(cell10GamOriginalWidth / 2)); const cell10GamHeight = Math.round(0.75 * Math.round(1.25 * Math.round(1.5 * Math.round(Math.max(120, Math.round(cell10GamOriginalWidth * 0.58)) / 2)))); const cell10GamPlot = cell10Plot.plot({ width: cell10GamWidth, height: cell10GamHeight, marginTop: 9, marginRight: 29, marginBottom: 21, marginLeft: 3, x: {domain: [0, 1500], ticks: [0, 500, 1000, 1500], label: "Distance (m)", tickSize: 0}, y: {domain: [1, 5], axis: "right", ticks: [1, 2, 3, 4, 5], label: null, tickSize: 0}, color: cell10RatingScale, style: {background: "transparent", color: "#303940", fontFamily: cell10Font, fontSize: "8.75px"}, marks: [ cell10Plot.ruleX(cell10Bands.filter(b => b.median !== null), { x: "radius", stroke: "median", strokeWidth: 1, strokeDasharray: `${cell10RingDashLength},${cell10RingDashGap}`, strokeOpacity: cell10RingOpacity, clip: true }), cell10Plot.ruleX(cell10Bands.filter(b => b.median === null), { x: "radius", stroke: cell10MissingRatingColor, strokeWidth: 1, strokeDasharray: `${cell10RingDashLength},${cell10RingDashGap}`, strokeOpacity: cell10RingOpacity, clip: true }), ...cell10GamLeaveOneOut.map(({fit, min, max}) => cell10Plot.line(cell10GamCurve(fit, min, max), { x: "distance", y: "predicted", stroke: "#d4c4ed", strokeOpacity: 0.9, strokeWidth: 1.4, clip: true })), ...(cell10GamReviewFit ? [cell10Plot.line(cell10GamCurve(cell10GamReviewFit, cell10GamReviewMin, cell10GamReviewMax), { x: "distance", y: "predicted", stroke: "#c29cdb", strokeWidth: 2, strokeDasharray: "4,3", clip: true })] : []), cell10Plot.line(cell10GamCurve(cell10GamPrimary, cell10GamMin, cell10GamMax), { x: "distance", y: "predicted", stroke: "#aa91d0", strokeWidth: 2.5, clip: true }), // Mark the Eiffel Tower at the zero-distance end of the horizontal axis. cell10Plot.dot([{distance: 0, rating: 1}], { x: "distance", y: "rating", symbol: "triangle", r: 3, dy: -4, fill: cell10BasemapColors["Tour Eiffel"], stroke: "none" }) ] }); const cell10GamAxisX = cell10GamWidth - 3; const cell10GamAxisY = 9 + (cell10GamHeight - 9 - 21) / 2; cell10GamPlot.append(cell10Htl.svg`Predicted rating`); cell10GamPlot.querySelectorAll("text").forEach(text => { text.setAttribute("stroke", "white"); text.setAttribute("stroke-width", "2"); text.setAttribute("stroke-linejoin", "round"); text.setAttribute("paint-order", "stroke"); }); // Native SVG title tooltips use browser-controlled fonts. Convert them into one // styled popup while keeping the same text as accessible labels on the marks. const cell10PopupText = new WeakMap(); cell10Map.querySelectorAll("title").forEach(title => { const mark = title.parentNode; if (mark === cell10Map) return; cell10PopupText.set(mark, title.textContent); mark.setAttribute("aria-label", title.textContent); title.remove(); }); const cell10Popup = cell10Htl.html``; const cell10MapContainer = cell10Htl.html`

${cell10Map}

${cell10Title}

${cell10Subtitle}

${cell10Legend} ${cell10MedianLegend}

Ring increments: 250 m

Paris AOI

${cell10Inset}

${cell10GamPlot}

GAM sensitivity fits

${cell10Popup}

`; cell10Map.addEventListener("pointermove", event => { let target = event.target; while (target && target !== cell10Map && !cell10PopupText.has(target)) target = target.parentNode; const value = target && cell10PopupText.get(target); if (!value) { cell10Popup.style.display = "none"; return; } cell10Popup.textContent = value; cell10Popup.style.display = "block"; const bounds = cell10MapContainer.getBoundingClientRect(); const x = event.clientX - bounds.left + 12; const y = event.clientY - bounds.top + 12; cell10Popup.style.left = `${Math.max(0, Math.min(x, bounds.width - cell10Popup.offsetWidth))}px`; cell10Popup.style.top = `${Math.max(0, Math.min(y, bounds.height - cell10Popup.offsetHeight))}px`; }); cell10Map.addEventListener("pointerleave", () => { cell10Popup.style.display = "none"; }); display(cell10Htl.html`

${cell10MapContainer}

Dashed circles and labels show the median rating in each 250 m band. Gray indicates no rating.

${cell10Bands.map(b => `${b.lower}–${b.radius} m: ${b.median === null ? "no ratings" : `median ${b.median.toFixed(3)} (n=${b.n})`}`).join(" · ")}

Scale 1:10,000 when the 500 m bar measures 5 cm on the printed or displayed map.

`); 56:[{"id":"da22d522f427766dfe656d959e7dad85bb0ff688b8c135bc756e02fd86fd64cbcd1b07b6f2ae656c678e6aa8c079cc83e46c32d4654e17192916c4ce8ce4d0eb","href":"https://static.observableusercontent.com/files/da22d522f427766dfe656d959e7dad85bb0ff688b8c135bc756e02fd86fd64cbcd1b07b6f2ae656c678e6aa8c079cc83e46c32d4654e17192916c4ce8ce4d0eb","name":"dataprep_droppedpoints.png","type":"image/png","lastModified":1793521990121,"size":1836042},{"id":"d80864e218636a5ea6ddf5454d2d058b81cd10c3bc4fe8e408aeadf7b2f90e3b8f157a226b03a4b123373a3cb2b76f11527b85c23fd7d525f64902bea5e0194c","href":"https://static.observableusercontent.com/files/d80864e218636a5ea6ddf5454d2d058b81cd10c3bc4fe8e408aeadf7b2f90e3b8f157a226b03a4b123373a3cb2b76f11527b85c23fd7d525f64902bea5e0194c","name":"eiffel_tower_shape.geojson","type":"application/octet-stream","lastModified":1793541533714,"size":13345},{"id":"d3adad78c8292f980c192ddb1047f8d4989e37ba1c46a87e77253b575183cba872695143a0472ea6970929ee16b780c596da3cfa65c9a4a8a8956884efac2f7f","href":"https://static.observableusercontent.com/files/d3adad78c8292f980c192ddb1047f8d4989e37ba1c46a87e77253b575183cba872695143a0472ea6970929ee16b780c596da3cfa65c9a4a8a8956884efac2f7f","name":"AOI.geojson","type":"application/octet-stream","lastModified":1793541533715,"size":541},{"id":"35dd782b9913ea5d45bf76d28d90a48330d2ddbd6ba4d1a4472da77b01099e5ad7f826529a39797a305d78f80c6ccc1406ab006ed8a0baea1a12c07b04e88d21","href":"https://static.observableusercontent.com/files/35dd782b9913ea5d45bf76d28d90a48330d2ddbd6ba4d1a4472da77b01099e5ad7f826529a39797a305d78f80c6ccc1406ab006ed8a0baea1a12c07b04e88d21","name":"basemap_paris_AOI.geojson","type":"application/octet-stream","lastModified":1793541533715,"size":14148816},{"id":"f963557e1b3734c482d1eb78b27aa3e9492fec5f5a38d6ababae95f77c8d0a2df41bc2b29216f90738d37ddcd250212eeb61b191ca3685c1da1be01fa52784c7","href":"https://static.observableusercontent.com/files/f963557e1b3734c482d1eb78b27aa3e9492fec5f5a38d6ababae95f77c8d0a2df41bc2b29216f90738d37ddcd250212eeb61b191ca3685c1da1be01fa52784c7","name":"eiffel_buffers.geojson","type":"application/octet-stream","lastModified":1793541533716,"size":119178},{"id":"0f35488a523a82e8874c3fb5c02ae97a1a63380a71e5c81ed3974ae117e24d4c8d773a1201bfaad89242bfd358e2798744e401459c580a4c11228327b5769540","href":"https://static.observableusercontent.com/files/0f35488a523a82e8874c3fb5c02ae97a1a63380a71e5c81ed3974ae117e24d4c8d773a1201bfaad89242bfd358e2798744e401459c580a4c11228327b5769540","name":"eiffel_tower_point.geojson","type":"application/octet-stream","lastModified":1793541533716,"size":325},{"id":"e3b6e1c4e9aadccec0f6ae7e0722860c2fe93a4282df7ebcc137c3f9c2dc400df3032fc7eefbeea7223f8de580eb75b4b50124c74a0558d6d5fc599c4cc41898","href":"https://static.observableusercontent.com/files/e3b6e1c4e9aadccec0f6ae7e0722860c2fe93a4282df7ebcc137c3f9c2dc400df3032fc7eefbeea7223f8de580eb75b4b50124c74a0558d6d5fc599c4cc41898","name":"restaurants_paris.geojson","type":"application/octet-stream","lastModified":1793600351276,"size":21103297},{"id":"f875e85199ce743c7b7b1db17b9bb561c94637d3af2517b8ff9183cdf6a8ffda5ede317ed20c1bdcbd6d96dbee37b358caf67cae4be6a62a88e1af2a79ef5975","href":"https://static.observableusercontent.com/files/f875e85199ce743c7b7b1db17b9bb561c94637d3af2517b8ff9183cdf6a8ffda5ede317ed20c1bdcbd6d96dbee37b358caf67cae4be6a62a88e1af2a79ef5975","name":"header.png","type":"image/png","lastModified":1793605954302,"size":327434}] 47:{"id":"10815a7ee82de8c5","slug":"the-eiffel-proximate-tourist-trap-effect","title":"The Eiffel-proximate Tourist Trap Effect","thumbnail":"86771b6eae8972a44866a773d384d8fef107323608f8f8a182757b096550c5e8","access_level":"public","create_time":"$D2026-11-01T07:45:19.435Z","update_time":"$D2026-11-02T15:47:06.800Z","view_time":null,"first_public_time":"$D2026-11-02T15:41:26.497Z","has_unpublished_edits":null,"fork":false,"stars":1,"starred":false,"owner":{"type":"team","id":"7c4453bfba6d243c","login":"geo-theo","name":"geo-theo","avatar_url":"https://avatars-next.observableusercontent.com/7c6e213507054a75d47cd8b842609fb692f2e960eb0ebe2d04712d7cf13d94b4","tier":"starter_2024","bio":"","followed_by_you":false,"follows_you":false},"version":504,"publish_version":504,"role":null,"authored":false,"authors":[{"type":"individual","id":"0ebe4fb56285b831","login":"geo-theo","name":"geo-theo","avatar_url":"https://avatars-next.observableusercontent.com/7c6e213507054a75d47cd8b842609fb692f2e960eb0ebe2d04712d7cf13d94b4","tier":null,"bio":"","followed_by_you":false,"follows_you":false}],"members":[{"type":"team","id":"7c4453bfba6d243c","login":"geo-theo","name":"geo-theo","avatar_url":"https://avatars-next.observableusercontent.com/7c6e213507054a75d47cd8b842609fb692f2e960eb0ebe2d04712d7cf13d94b4","tier":"starter_2024","role":"editor"}],"comments":[],"custom_thumbnail":true,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"The Eiffel-proximate Tourist Trap Effect","cells":[{"id":1,"value":"

\n\n# The Eiffel-proximate Tourist Trap Effect\n## #30DayMapChallenge Day 01 (Points)\n\n

","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":38,"value":"FileAttachment(\"header.png\").image()","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2,"value":"Growing up in France I often heard both residents and visitors joking about restaurants' worsening quality of food & service the closer you get to the Eiffel Tower. Surely we can model the spatial relationship between restaurant quality and how it is affected by every step you take towards the alleged tourist trap?\n\n**Let's test this hypothesis with distance-rating spatial statistics:**\n- H0: points closer to the Eiffel Tower exhibit a random mix of ratings.\n- H1: points closer to the Eiffel Tower tend to have lower ratings.\n\n

","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":18,"value":"$4c","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":33,"value":"Hover over each point to see the average rating.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3,"value":"

\n\n## Data Processing","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":14,"value":"The point locations come from a massive Kaggle [dataset](https://www.kaggle.com/datasets/stefanoleone992/tripadvisor-european-restaurants) (scraped and compiled by Stefano Leone) containing over a million TripAdvisor restaurants across Europe.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":53,"value":"$4d","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":10,"value":"Some data cleaning steps are needed before the analysis:\n1. Filter the dataset for Paris restaurants;\n2. Reproject to meters-based CRS (EPSG:2154) for distance-based analytics;\n3. Drop incorrectly geocoded restaurant locations;\n4. Drop restaurants located within the Eiffel Tower;\n5. Calculate distance between each point and the Eiffel Tower;\n6. Add 250m incremented buffers up to 1500m.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":11,"value":"FileAttachment(\"dataprep_droppedpoints.png\").image()","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":36,"value":"It seems reasonable to drop the restaurants that are physically located in the Eiffel Tower, as these would not be part of the proximity/quality relationship that this analysis hopes to investigate. Also included in these points are a couple incorrectly-geocoded restaurants that are good to drop.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":15,"value":"The maximum radius for the Area of Interest is meant to reduce any effects that other tourism sites in Paris may have on restaurant quality. 1.5km was the perfect radius to not encroach on other POIs' area of effect.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":48,"value":"

\n\n## Spatial Regressions on Distance-Rating","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":39,"value":"

\n\n### OLS Linear Regression","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":52,"value":"$4e","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":54,"value":"Some interesting Simpson's Paradox observations from the interactive scatterplot:\n- the distance-rating relationship is positive and statistically strongest for mid-tier (€€-€€€), but is negative for low-tier (€) and high-tier price levels (€€€€).\n- the distance-rating relationship is positive and statistically strongest for French cuisine, but the complete opposite seems to be true for Japanese cuisine (where closer proximity to the Eiffel tower seems to significantly increase the ratings of Japanese restaurants).","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":55,"value":"Due to some of the geocoding errors that were caught in the data processing stage, the reliability of these variables is certainly put into question when there is the possibility for different interpretations in how attributes are being encoded (different geocoding standards and practices, different interpretations of cuisine, is price level arbitrary? etc).","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":43,"value":"

\n\n### Spearman's Rank Correlation","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":58,"value":"$4f","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":59,"value":"There is both a statistically significant, and a moderately positive association between distance and ratings when in the closest distance band (<500m). For the full AOI and for the further 500m-1500m band, even though there is a slight indication of positive association, there is no statistically significant evidence that ratings keep increasing with distance.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":44,"value":"

\n\n### Distance bands with ordered trend test","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":51,"value":"##### Jonckheere-Terpstra Test","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":60,"value":"$50","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":61,"value":"All in-range rated restaurants have distance bands consistent with their numeric distances. All six expected rated counts match. In-range missing ratings: 81; invalid or missing distances: 0.\n\nAll bands: The test provides evidence of an increasing ordered trend (p = 0.0480; P = 0.5222, D = 0.0445). Beyond 500 m: The test does not provide sufficient evidence of an increasing ordered trend (p = 0.1976; P = 0.5117, D = 0.0234). The second analysis is exploratory; a nonsignificant result does not prove the relationship disappears. Comparing these results does not directly test whether the effects differ. Confidence intervals are not calculated.\n\nP counts tied cross-band comparisons as half; D = 2P − 1. These are normalized pairwise measures, not correlations. The test concerns ordered differences, not necessarily a linear or continuous increase.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":63,"value":"##### Distance Band Statistics","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":64,"value":"$51","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":46,"value":"

\n\n### Generalized Additive Model (GAM)","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":66,"value":"1070 rated restaurants within 1,500 m; observed distances 166–1499 m. The model uses the continuous distance and rating values.\n\nRMSE gives larger errors more weight. Residual standard deviation uses n − EDF as an approximate residual degrees-of-freedom adjustment. R² and RMSE describe the data used to fit the curve; they do not measure out-of-sample accuracy or test whether the relationship is nonlinear. GCV and the smoothing penalty describe model fitting rather than statistical significance.\n\nThe blue line estimates the average rating at each distance; the dashed orange line is a straight-line reference. The vertical guide marks 500 m. The GAM does not control for restaurant characteristics, and the graph does not establish cause and effect. There are 9 observations within 250 m, so the curve near the tower is especially sensitive to individual restaurants. Ratings are bounded from 1 to 5, while this Gaussian model does not enforce those bounds.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":65,"value":"$52","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":47,"value":"

\n\n### Center-anchored Permutation Test","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":68,"value":"Usable restaurants: 1,070. Primary eligible radii: 325–1475 m, at 25 m intervals (minimum 20 per group).\n\nPrimary global one-sided permutation p-value: 0.0075; maximum standardized difference: 3.478 at 350 m; largest raw difference: 0.505 at 350 m. 9,999 permutations; seed 20261102.\n\nEach point compares all restaurants at or within the radius with all restaurants outside it up to 1,500 m. These are cumulative comparisons, not 25 m ring averages. Only eligible radii are drawn; the envelope is simultaneous across the primary scan, not a pointwise interval.\n\nGlobal one-sided p-value: 0.0075. Largest standardized difference: 350 m (Z = 3.478).","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":67,"value":"$53","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":69,"value":"$54","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":7,"value":"

\n\n## Conclusion","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":70,"value":"$55","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":28,"value":"Three patterns stick out:\n1. Restaurants within immediate proximity (<250m) of the Eiffel Tower are significantly worse-rated, but beyond 400m the ratings don't really improve from increasing distance.\n2. Bad neighborhood near Bir-Hakem.\n3. Good neighborhood near Rue Saint-Dominique\n\nThe Spearman coefficient and GAM gives us the strongest evidence that points closer to the Eiffel Tower do not exhibit a random distribution of ratings, and we can reasonably reject the null hypothesis.\n**There is statistical evidence that the Eiffel-proximate tourist trap effect is strong for closeby restaurants but tapers off to a negligible effect when further than 500m distance.**","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":29,"value":"

\n\n## Limitations of the dataset\nRatings are just estimates and have so many other factors contributing to them (especially with automated review activity online) that it is hard to take it seriously for statistical rigour.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W56","stdlib":"2"}} 42:null