Plotting Collatz conjecture values - Python

Question

I am writing a program to display the behavior or certain seeds when you apply the Collatz conjecture algorithm to them. I would like to know what I should change and also if there is a way to see which seed produced a certain plot. I am also having some problems with the color.

import matplotlib.pyplot as plt import numpy as np def collatz(seed): """Apply Collatz conjecture algorithm and stores all the values of the seed after every iteration to display them later""" y = [seed] while seed != 1: if seed % 2 == 0: seed = seed/2 else: seed = (3*seed) + 1 y.append(seed) return y colors = plt.cm.bwr(np.linspace(0, 1, 1500)) for i in range(1, 1500): #collecting data by applying the algorithm to a certain set of seeds Y = collatz(i) plt.plot(Y, color = colors[i]) plt.title("Collatz conjecture") plt.xlabel("Number of iterations until stuck") plt.ylabel("Values reached") plt.show() 

Answer 1

Note how you're manually repeating the number of seeds (1500):

colors = plt.cm.bwr(np.linspace(0, 1, 1500)) for i in range(1, 1500): ... 

That's always a good sign it should be a variable.

One option is to put the plotting code into a function parametrized by n_seeds (and then add 1 to make the naming accurate):

def plot_collatz(n_seeds=1500): # ------------ """Plot Collatz sequences for a given number of seeds""" colors = plt.cm.bwr(np.linspace(0, 1, n_seeds+1)) # --------- for seed in range(1, n_seeds+1): # --------- plt.plot(collatz(seed), color=colors[seed]) plt.title("Collatz conjecture") plt.xlabel("Number of iterations until stuck") plt.ylabel("Values reached") plt.show() plot_collatz(10) 

Answer 2

Integer arithmetic

seed = seed/2 takes the value of seed (initially an integer) and divides it by 2, and stores the result as a float back in seed.

>>> 10 / 2 5.0 

If the collatz sequence value ever exceeds \$2^{53}\$, seed % 2 == 0 will always be true, due to the limited float precision.

>>> 2 ** 53 + 1.0 # You'd expect this to be odd, but it's not! 9007199254740992.0 

Instead, you should be using integer division: seed = seed // 2. Python's integers have variable length representations, so can easily hold exceedingly large integer values precisely.

You could also use an Augmented Assignment operator here (seed //= 2). It saves typing a variable name an additional time, and -- when the left-hand-side is more complex than a simple variable, such as self.seed or a[i] -- avoids evaluating the term a second time, which can be a speed improvement.

Answer 3

identifiers

The literature tends to speak of "values" generated by the \$3n+1\$ process. A "seed" is used to start the process, and we see successive values grow from there. It is perfectly sensible to accept a seed parameter. But during the growth loop, please use another name, perhaps n.

annotation

It wouldn't hurt to point out we accept seed: int, since a variant rational processes might perform the hailstone operation on a seed: Fraction. (Though I confess the lack of from fractions import Fraction is kind of a tip-off, here.)

It would also set you up for a numba JIT decorator.

single responsibility

Thank you for this beautiful docstring.

def collatz(seed): """Apply Collatz conjecture algorithm and stores all the values of the seed after every iteration to display them later""" 

It is concise and accurate. It also helps us to see we are doing

1. compute and
2. store

Consider focusing on compute, so storage is someone else's problem.

from typing import Generator def collatz(seed: int) -> Generator[int, None, None]: """Generates hailstone values.""" n = seed while n > 1: if n % 2: n = 3 * n + 1 else: n //= 2 yield n def main(num_seeds: int = 1500) -> None: ... for seed in range(1, num_seeds + 1): y = list(collatz(seed)) ... 

color maps

The cm.bwr colormap is very nice. You might consider playing with cyclic colormaps, to highlight the chaotic non-linear nature of the data you're plotting. Or cycle through a categorical map.

You may find that plotting points rather than lines, and using a partly transparent beta, allows you to achieve higher visual data density.

caching

If you summarize a given seed as producing an (iterations, max_value) tuple, you might find the @lru_cache or @cache decorators to be helpful; or introduce your own caching array. The literature sometimes uses delay to describe number of iterations for a given seed. Leavens and Vermeulen did some interesting work in this space in 1992.

Of course, the calculations we're doing are so lightweight that time spent on cache checks threatens to swamp the time spent calculating. So we'd want to unroll a bit, perhaps by doing half a dozen "ordinary" function calls followed by one where we check the cache. Or equivalently, to handle every seventh seed, do a modulo congruent to zero test. Or perhaps use some bigger prime.