Skip to main content
SimilarExport ZIP
100%

An example of reversing bits in a 32-bit number

✓ Published0🌍 Public
HHugoberry
Last edited Jan 24, 2017
Created on Jan 24, 2017

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.

AI-generated description

Similar vizzes

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
83% 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
75% match
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
57% match
Loading thumbnail…

Precomputin the CRC32 lookup table

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.

HHugoberry
54% 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
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
48% match
Loading thumbnail…

Gist 8abd0d0a72b91b4d72ce79ac9d8ab6c4

This example demonstrates how Power Query’s `BinaryFormat.List` function reads binary data as a sequence of items, returning a list. It shows three distinct modes: reading until the data ends, reading a fixed number of items, and using a condition function to stop based on item values. The code constructs sample binary data with `#binary`, then applies `BinaryFormat.List` with `BinaryFormat.Byte` as the item format. The condition variant passes a lambda `(x) => x < 2` that continues reading while true, including the first failing item. The output lists (e.g., `{1, 2, 3}`) directly display the parsed bytes.

HHugoberry
48% match
Loading thumbnail…

Binary and Hex Conversion in Julia

This example defines two recursive Julia functions, `tobin` and `tohex`, that manually convert a decimal integer into its binary and hexadecimal string representations. The code demonstrates pattern matching with the `Match` package: `tobin` handles base 2, while `tohex` maps digits 0–9 and letters A–F for base 16, using the `div` and `mod` functions to decompose the input. The functions are intended to be compared against Julia’s built-in `bits()` and `hex()` utilities, though no visualization or data source is included.

CCliffordAnderson
48% match