Shamochu

Shamochu is short for “Shuffle and merge overlapping chunks lossless compression”.

See the package description for a complete presentation

Input

type Chunk = Vector

A chunk of the input data

Compressed array

data CompressedArray e

Compressed array

See also: compressChunks and decompressedArray.

Since: 0.1.0

Constructors

CompressedArray

Fields

• array :: !(Chunk e)
• offsets :: !(Chunk Int)
• sizes :: !(Chunk Int)

Instances

(Show e, Unbox e) => Show (CompressedArray e)

Defined in Shamochu

Methods

showsPrec :: Int -> CompressedArray e -> ShowS

show :: CompressedArray e -> String

showList :: [CompressedArray e] -> ShowS

(Unbox e, Eq e) => Eq (CompressedArray e)

Defined in Shamochu

Methods

(==) :: CompressedArray e -> CompressedArray e -> Bool

(/=) :: CompressedArray e -> CompressedArray e -> Bool

makeChunks

Arguments

:: (Unbox e, Ord e)

=> Word

Chunk size

-> Vector e

Sequence to compress

-> Vector (Vector e)

>>> makeChunks @Word 2 [1..9]
[[1,2],[3,4],[5,6],[7,8],[9]]

Since: 0.1.0

compressChunks :: forall e. (HasCallStack, Unbox e, Ord e) => Vector (Vector e) -> CompressedArray e

Compress a sequence of Chunks

>>> compressChunks @Word [[1,2,3],[2,3,4],[3,1,2]]
CompressedArray {array = [3,1,2,3,4], offsets = [1,2,0], sizes = [3,3,3]}

Since: 0.1.0

decompressedArray :: (Unbox e, Ord e) => CompressedArray e -> Vector e

Decompress a CompressedArray

\s (xs :: [Word]) -> let cs = makeChunks (1 + div s 4) (U.fromList xs) in decompressedArray (compressChunks cs) == V.foldMap' id cs

Since: 0.1.0

data CompressedBlob e

Result of the two-stages compression

See also: compress and decompress.

Since: 0.1.0

Constructors

OneStage

Array compressed using one offsets array.

Fields

• array1 :: !(CompressedArray e)

  Compressed data array

• stats :: !(Stats e)

  Statistics of the compression

TwoStages

Array compressed using two offsets arrays.

Fields

• array1 :: !(CompressedArray e)

  Compressed data array

• array2 :: !(CompressedArray Int)

  Compressed offsets of the data array

• stats :: !(Stats e)

  Statistics of the compression

Instances

(Show e, Unbox e) => Show (CompressedBlob e)

Defined in Shamochu

Methods

showsPrec :: Int -> CompressedBlob e -> ShowS

show :: CompressedBlob e -> String

showList :: [CompressedBlob e] -> ShowS

(Unbox e, Eq e) => Eq (CompressedBlob e)

Defined in Shamochu

Methods

(==) :: CompressedBlob e -> CompressedBlob e -> Bool

(/=) :: CompressedBlob e -> CompressedBlob e -> Bool

compress

Arguments

:: forall e. (FiniteBits e, Unbox e, Ord e)

=> NonEmpty Word

Chunk sizes to use for stage 1

-> [Word]

Chunk sizes to use for stage 2. If empty, stage 2 will not be run.

-> Vector e

-> CompressedBlob e

Compress a sequence in two stages

1. Using 2 tables: data and offsets.
2. Using 3 tables: data, offsets1 and offsets2.

Since: 0.1.0

decompress :: (Unbox e, Ord e) => CompressedBlob e -> Vector e

Decompress a CompressedBlob.

\x (xs :: [Word]) -> let ys = U.fromList (take 300 (cycle (mconcat (L.permutations (x:xs))))) in decompress (compress [2,3,4] [1] ys) == ys

Since: 0.1.0

Stats

data Stats e

Statistics about the compression

Since: 0.1.0

Constructors

Stats

Fields

• originalSize :: !Natural
• compressedSize :: !Natural
• ratio :: !(Ratio Natural)
• dataLength :: !Word
• dataIntSize :: !Word
• dataRange :: !(e, e)
• dataOverlaps :: !Word
• dataChunkSizeLog2 :: !Word
• offsets1Length :: !Word
• offsets1IntSize :: !Word
• offsets1Range :: !(Int, Int)
• offsets1ChunkSizeLog2 :: !Word
• offsets2Length :: !Word
• offsets2IntSize :: !Word
• offsets2Range :: !(Int, Int)

Instances

Show e => Show (Stats e)

Defined in Shamochu

Methods

showsPrec :: Int -> Stats e -> ShowS

show :: Stats e -> String

showList :: [Stats e] -> ShowS

Eq e => Eq (Stats e)

Defined in Shamochu

Methods

(==) :: Stats e -> Stats e -> Bool

(/=) :: Stats e -> Stats e -> Bool