DAX measure that formats a measure `[Quantity]` into a roman numeral

A DAX measure definition that formats the Revenue numbers in a wordly way. It spells out numbers 1,812,343,434,567,812 like to `one quadrillion eight hundred and twelve trillion three hundred and forty-three billion four hundred and thirty-five million five hundred and sixty-eight thousand eight hundred and twelve`

This example demonstrates a DAX measure that converts a numeric Revenue value into its fully spelled-out English text, such as rendering 1,812,343,434,567,812 as “one quadrillion eight hundred and twelve trillion…” The measure uses the `CONCATENATEX` iterator with `GENERATESERIES` to break the number into groups of three digits, then applies nested `SWITCH` and `LOOKUPVALUE` functions against three lookup tables—`DigitWords`, `NumberWords`, and `Magnitude`—to map each group to its word form. The code also relies on `ADDCOLUMNS` for intermediate calculations and `ROUND` and `MOD` for digit extraction. The visualization shows the formatted result directly as text, with the lookup tables defined via the `DATATABLE` function.

79% match

Exploring displaying microcharts and sparklines in table/matrix visual in PowerBI

This example demonstrates how to embed a wide range of microcharts and sparklines directly into Power BI table and matrix visuals using a single DAX measure. The measure returns a text string composed of Unicode block characters, which the visual renders as the final chart. The code includes a calculation table with pattern definitions for bar charts, bullet charts, win/loss charts, dot plots, candlestick charts, and horizontal comparison bars, each using characters like blocks, circles, and lines. The approach requires no external libraries, relying solely on DAX string manipulation and the native Unicode font rendering in the Power BI visual.

55% match

Gist ba3a80c35942582d77235e9fb4173416

This example shows a small, inline sparkline generated as a Scalable Vector Graphic (SVG) image URL from a Power BI measure. It plots a measure’s values over time for a single category, mapping each date to an X coordinate and each value to a Y coordinate within a 100×100 viewBox. The code uses DAX variables like `MINX`, `MAXX`, and `SUMMARIZE` to compute the normalized coordinates, then concatenates them into a `polyline` string. The result is rendered as a data URI with `data:image/svg+xml;utf8`, relying on the table’s `Date` and `Category` fields.

54% match

K-means clustering in DAX

This example demonstrates a K-means clustering implementation written in DAX, showing how to group items into clusters based on multiple numeric attributes. The code computes a transformed table using `SUMMARIZECOLUMNS` to aggregate attribute values per item, then passes that table to a custom `KMeansClustering` function. The function assigns each item a `ClusterId` while preserving the original item labels. The visualization highlights the resulting clusters, with the DAX code serving as the core analytical engine rather than relying on a JavaScript library. The source is a gist by Hugoberry, and the rendering approach is not visible here, so the focus remains on the clustering logic and the data transformation pipeline.

51% match

Gist 67bf315eb5b9cafa9a5899b88f252dab

This example shows a bill-of-materials (BOM) data-transformation pipeline, expanding each assembly component by a numeric factor to generate multiple line-item rows. The Power Query M code in `BOMsourcer.pq` duplicates rows based on the `Factor` column, then reconstructs hierarchical identifiers by concatenating `ProductAssemblyID`, `ComponentID`, and the expanded custom counter using text delimiters (`.`, `:`) via `Table.CombineColumns` and `Table.ExpandListColumn`. It renames and reorders columns, casts date and numeric types, and merges component and product fields into single keys, ultimately preparing the data for downstream visualization or analysis. The visible operations rely on standard Power Query table functions rather than a specific charting library.

DEC2BIN or HEX2BIN in Power Query M

This example demonstrates a Power Query M function that converts a decimal number to its binary string representation, implementing the equivalent of Excel’s DEC2BIN and HEX2BIN operations. The function, `Number.DEC2BIN`, takes a numeric input and uses `List.Generate` to iteratively extract bits via `Number.BitwiseAnd` and `Number.BitwiseShiftRight`. Each iteration prepends the least significant bit to an accumulating string, while the loop continues until the remainder becomes zero. The code relies on M’s native `Number.ToText` for bit conversion and explicitly shows the bitwise arithmetic and list-generation logic, with no external libraries or data sources involved.

Convert from Base 10

This example demonstrates base conversion by transforming the decimal integer 1024 into its binary equivalent, visually showing how repeated division by the target base produces the final digits. The code defines two XQuery 3.1 functions, `local:convert-base` and `local:join-nums`, which recursively divide the input by the base and concatenate the remainders into a single integer using `fn:string-join`. No external visualization libraries are used; the rendering relies entirely on XQuery’s native sequence and string operations to produce the output. The result appears as a numeric readout rather than a plotted chart.

CCliffordAnderson

Superscript Format

A log-scale axis displays powers of ten from 10⁰ to 10⁹, with tick labels formatted using superscript characters (⁰¹²³⁴⁵⁶⁷⁸⁹) via a custom `formatPower` function that maps each digit to its Unicode superscript equivalent. The example uses d3.v3's `d3.scale.log` and `d3.svg.axis`, with tick formatting defined by a custom function passed to `.ticks(10, ...)`. The SVG rendering places the axis with generous top and bottom margins, and the code notes the vertical alignment issue between superscripts and normal digits.

Mmbostock