Direct equality of two CostStreams. Same as deriving stock Eq. We don't want to do the latter, because the semantics of a CostStream are those of the sum of its elements and the derived Eq instance would conflict with that.

A list of ranges: (0, 0), (1, 10) : (11, 100) : (101, 1000) : ... : [(10^18, maxBound)].

Return the range (in the sense of magnitudes) in which the given SatInt belongs. E.g.

>>> toRange 42
(11,100)
>>> toRange 1234
(1001,10000)

Generate a SatInt in the given range.

Same as (===) except accepts a custom equality checking function.

A value to use in tests to make sure what's not supposed to be forced isn't forced.

Test that magnitudes has the correct bounds.

Show the distribution of generated CostStreams as a diagnostic.

Test that fromCostList . toCostList is identity.

Test that toCostList . fromCostList is identity.

Test that uncurry reconsCost . unconsCost is identity.

Test that sumCostStream returns the sum of the elements of a CostStream.

Test that mapCostStream applies a function to each element of a CostStream.

Test that the sum of a stream returned by addCostStream equals the sum of the sums of its two arguments.

Test that the sum of a stream returned by minCostStream equals the minimum of the sums of its two arguments.

Test that the sum of a stream returned by zipCostStream equals an ExBudget containing the sums of its two arguments.

Test that mapCostStream preserves the length of the stream.

Test that the length of the stream returned by addCostStream equals the sum of the lengths of its two arguments.

Test that the length of the stream returned by addCostStream is

1. greater than or equal to the minimum of the lengths of its two arguments
2. smaller than or equal to the sum of the lengths of its two arguments.

Test that the length of the stream returned by zipCostStream equals the maximum of the lengths of its two arguments.

Test that mapCostStream preserves the laziness of its argument.

Test that mapCostStream preserves the laziness of its two arguments.

Test that minCostStream preserves the laziness of its two arguments.

Pad the shortest of the given lists by appending the given element to it until the length of the result matches the length of the other list.

>>> postAlignWith 'a' "bcd" "e"
("bcd","eaa")
>>> postAlignWith 'a' "b" "cdef"
("baaa","cdef")

Test that zipCostStream preserves the laziness of its two arguments.

The size sierpinskiRose of the given depth.

Return a finite balanced tree with each node (apart from the leaves) having exactly 3 children. The parameter is the depth of the tree. Named after https://en.wikipedia.org/wiki/Sierpi%C5%84ski_triangle

Traverse a sierpinskiRose of the given depth and display the total amount of elements processed. See test_flattenCostRoseIsLinear for why we do this.

Test that traversing a larger CostRose takes _linearly_ more time. The actual test can only be done with eyes unfortunately, because the tests are way too noisy for evaluation times to be reported even remotely accurately.

Generate a CostRose from the given list by splitting the list into sublists and generating a CostRose for each of them recursively.

Return the lengths of all the forests in a CostRose.

Show the distribution of forest lengths in generated CostRose values as a diagnostic.

Test that genCostRose only takes costs from its argument when generating a CostRose.

Test that flattenCostRose returns the elements of its argument.

Test that flattenCostRose is lazy.

Test that memoryUsage called over a value of a built-in type never returns a stream containing a negative cost.