Precomputin the CRC32 lookup table

100%

Precomputin the CRC32 lookup table

✓ Published0🌍 Public

Last edited Feb 27, 2017

Created on Feb 27, 2017

This example visualizes the precomputation of a CRC32 lookup table, showing how 256 polynomial division results are generated for each possible input byte. The code defines a function that calculates CRC values by iterating through bit shifts and conditional XOR operations, using the polynomial 0x4C11DB7. It then employs List.Generate to build the complete lookup table, mapping each byte value (0–255) to its corresponding CRC result. The visualization highlights the algorithmic structure of CRC table generation, with Power Query’s number and bitwise functions (Number.BitwiseShiftLeft, Number.BitwiseXor) driving the computation.

AI-generated description

Similar vizzes

Loading thumbnail…

CRC32 implementation in Power Query M mostly inpired by the article about CRC32 computation http://www.sunshine2k.de/articles/coding/crc/understanding_crc.html and Bit Hacks https://graphics.stanford.edu/~seander/bithacks.htm

This example demonstrates a complete CRC32 implementation written in Power Query M, showing how to compute cyclic redundancy checks entirely within a data-transformation language. It displays both the algorithm’s core logic and its practical output as a hexadecimal checksum. The code defines a reverse function for 8-bit and 32-bit values, precomputes a lookup table using a polynomial of 0x4C11DB7, and iterates over input characters with an accumulator function. It relies on Power Query’s `Number.BitwiseAnd`, `Number.BitwiseShiftLeft`, `Number.BitwiseXor`, and `List.Accumulate` APIs. The final result reverses the raw CRC, XORs with 0xFFFFFFFF, and formats it as uppercase hex via `Number.ToText`. The source is a gist by Hugoberry, drawing from external CRC tutorials and bit-hack references.

HHugoberry

78% match

Loading thumbnail…

Function for reversing the bits in a 32bit number

The example demonstrates a custom function that reverses the order of bits in a 32-bit unsigned integer, a common low-level operation used in bit manipulation. It shows the step-by-step isolation and recombination of individual bytes (b0 through b3) before reversing the bits within each byte. The code relies on Power Query’s `Number.BitwiseAnd`, `Number.BitwiseShiftRight`, `Number.BitwiseShiftLeft`, and `Number.BitwiseOr` functions to mask, shift, and reassemble the bytes. A helper `reverse` function is implied for per-byte bit reversal, though not defined here. The visualization itself is a code snippet, not a graphical chart, highlighting the algorithmic logic rather than data representation.

HHugoberry

57% match

Loading thumbnail…

Gist 10da47bd381918d303c5db903afe5886

This example demonstrates how to generate all non-empty combinations of a set of strings using bitmask arithmetic. It shows three separate Power Query (M) implementations, each taking a hardcoded list like {"B", "F", "T"} and producing every possible subset as concatenated text. The primary approach uses `Number.BitwiseAnd` and `Number.Power` to iterate through binary masks, while `List.Transform`, `List.Select`, and `List.Positions` filter and combine elements. A recursive alternative using `@fnCombinations` is also included. The visualizations highlight different algorithmic strategies—iterative bitwise versus recursive decomposition—for the same combinatorial output, with no external libraries beyond Power Query’s built-in list functions.

HHugoberry

57% match

Loading thumbnail…

Generating Mandelbrot set in Power Query

This example renders the Mandelbrot set entirely within Power Query by generating a 1080-point sequence with `List.Generate`, mapping each point to the complex plane, and iterating the classic Mandelbrot formula to compute escape values. It visualizes the resulting 2D grid of iteration counts as a static bitmap, relying on Power Query’s built-in table and chart capabilities rather than external libraries. The code exposes a compact, functional approach to fractal generation, directly showing how iteration-based math translates into a visual image without specialized graphics APIs.

HHugoberry

56% match

Loading thumbnail…

An example of reversing bits in a 32-bit number

This example demonstrates how to reverse the bits of a 32-bit integer using a series of bitwise operations, applied to a specific input value. It shows the step-by-step process of extracting individual bytes, reversing their bit order, and reassembling them into the final result. The code uses PowerShell’s built-in bitwise operators like `-band`, `-shr`, and `-shl` to perform the manipulation, with helper functions `reverse` and `reverse64` providing alternative implementations. The input `0x04c11db7` is processed, and the output is printed in hexadecimal format, illustrating the reversal effect without any external libraries or visualization frameworks.

HHugoberry

54% match

Loading thumbnail…

PowerQuery hexview

The example visualizes a hexadecimal dump of a file’s raw bytes as a grid, where each cell represents one byte’s value in uppercase hex notation. The PowerQuery code reads the file `gitignore_global.txt` using `File.Contents` and `BinaryFormat.List`, then maps each byte to its relative and offset position within the file. Non-printable characters are replaced with dots, while printable ones display as hex pairs. The resulting table is expanded via `Table.ExpandRecordColumn`, producing a row per byte with columns for the byte value, its modulo-16 column, and the offset base—offering a compact, text-based visual breakdown of binary content without external charting libraries.

HHugoberry

54% match

Loading thumbnail…

Function to reverse an 8 bit number

This example visualizes the process of reversing an 8-bit number, showing the bitwise transformation from input to output. The code uses the `Number.Mod` and `Number.BitwiseAnd` JavaScript APIs to perform the reversal, applying the bitmask `0x010884422010` and multiplication factor `0x0202020202` as part of the algorithm. The visualization renders the data as a compact graphic, with each step of the reversal represented spatially, though the exact rendering method is not detailed in the source. The gist, authored by Hugoberry, provides a minimal, functional demonstration of the reversal logic in a single line.

HHugoberry

53% match

Loading thumbnail…

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.

HHugoberry

53% match