Numeric units in English? 3D visualization in Python, from battleships to vigintillians.

Hello, everyone! Today we're here with a really exciting topic: how to express numerical units in English and how to use them in the PythonHave you ever heard the word "Vigintillion" before? Can you imagine how big a number that is?

Today, we're going to take some of the largest numerical units in the English language, starting with 'Thousand' and ending with 'Vigintillion', and turn them into stunning 3D graphs using Python's Matplotlib library. In the process, we'll gain a visual understanding of the scale of numbers and experience Python's powerful data visualization capabilities. Let's get started!

The expanded world of English numeral units

Did you know that there are bigger units in the English language to represent large numbers than the ones we're familiar with like "Million," "Billion," and "Trillion"? Today we'll cover the following numerical units

1. Thousand (10³, one thousand)
2. Million (10⁶, million)
3. Billion (10⁹, billion)
4. Trillion (10¹², sunshine)
5. Quadrillion (10¹⁵, trillion)
6. Quintillion (10¹⁸, cirrus)
7. Sextillion (10²¹, ten years)
8. Septillion (10²⁴, date)
9. Octillion (10²⁷, thousandths)
10. Nonillion (10³⁰, white sheep)
11. Decillion (10³³, nineteen)
12. Undecillion (10³⁶, per day)
13. Duodecillion (10³⁹, celestial)
14. Tredecillion (10⁴², white crystals)
15. Quattuordecillion (10⁴⁵, ten quarters)
16. Quindecillion (10⁴⁸, unipolar)
17. Sexdecillion (10⁵¹, celestial pole)
18. Septendecillion (10⁵⁴, One Hundred Thousandth)
19. Octodecillion (10⁵⁷, twelve trillion)
20. Novemdecillion (10⁶⁰, Ilna Utah)
21. Vigintillion (10⁶³, Tennessee)

These units are often used in science, astronomy, or theoretical math, and they're numbers that you don't see every day.

3D visualization of numerical units in Python

Now we're going to visualize these huge numerical units in 3D using Python's Matplotlib library. We'll create a 3D bar graph to intuitively compare the size of each unit.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

Prepare the # data
units = [
    'Thousand', 'Million', 'Billion', 'Trillion', 'Quadrillion', 'Quintillion',
    'Sextillion', 'Septillion', 'Octillion', 'Nonillion', 'Decillion',
    'Undecillion', 'Duodecillion', 'Tredecillion', 'Quattuordecillion', 'Quindecillion',
    'Sexdecillion', 'Septendecillion', 'Octodecillion', 'Novemdecillion', 'Vigintillion'
]
values = np.array([10**3, 10**6, 10**9, 10**12, 10**15, 10**18, 10**21, 10**24, 10**27, 10**30, 10**33,
                   10**36, 10**39, 10**42, 10**45, 10**48, 10**51, 10**54, 10**57, 10**60, 10**63], dtype=float)
colors = plt.cm.viridis(np.linspace(0, 1, len(units)))

Set up the # 3D graph
fig = plt.figure(figsize=(20, 15))
ax = fig.add_subplot(111, projection='3d')

Data for plotting the # bar graph
x = np.array(len(units))
y = np.zeros_like(x)
z = np.zeros_like(x)

dx = dy = 0.8
dz = np.log10(values)

Create a # 3D bar graph
scatter = None
bars = []
for i, (value, color) in enumerate(zip(dz, colors)):
    bar = ax.bar3d(x[i], y[i], z[i], dx, dy, value, color=color, alpha=0.8)
    bars.append(bar)

Set the # axis labels
ax.set_xticks(x)
ax.set_xticklabels(units, rotation=45, ha='right')
ax.set_ylabel('Y axis')
ax.set_zlabel('Log10 of Value')

Set the # title
plt.title('3D Visualization of Extended English Number Units (up to Vigintillion)', fontsize=16)

# Add a color bar
plt.tight_layout()
plt.subplots_adjust(right=0.8) # Add right margin

Create a # color map
norm = plt.Normalize(vmin=min(dz), vmax=max(dz))
sm = plt.cm.ScalarMappable(cmap=plt.cm.viridis, norm=norm)
sm.set_array([])

Add a # colorbar (create separate Axes)
cax = fig.add_axes([0.85, 0.15, 0.03, 0.7]) # [left, bottom, width, height]
cbar = plt.colorbar(sm, cax=cax)
cbar.set_label('Log10 of Value', rotation=270, labelpad=15)

plt.show()

Code commentary

1. Import the necessary libraries. Numpy does the math and Matplotlib creates the graphs.
2. Prepare English numeric units and their corresponding values. This time, we've expanded it to 'Vigintillion'.
3. Set up a 3D graph and draw a bar for each unit. Use the bar3d function to generate the 3D bars.
4. Set axis labels and titles, and add color bars to intuitively represent the magnitude of values.
5. Use a logarithmic scale to effectively represent differences between large numbers. This way, you can show huge differences in size from "Thousands" to "Vigintillion" in one graph.

Numeric in English - The Feel of Python 3D Graphs

This 3D graph gives you a good idea of the scale of English numerical units: as you go from 'Thousand' to 'Vigintillion', the size of the numbers increases exponentially, but because we're looking at it on a logarithmic scale, it simply appears to increase sequentially.

Visualizations like this make it easier for us to understand the concept of big numbers - we can intuitively grasp how big a 'Billion' is, or how huge a 'Vigintillion' is, and by using Python 3D graphs, we can bring the scale of the numbers to life, not just in terms of height, but also in terms of space.

Organize

Today we learned how to express numerical units in English, and visualized them in Python 3D graphs, so we could compare unimaginably large numbers at a glance, from 'Thousand' to 'Vigintillion'.

Through this process, we realized how powerful visualization can be over simply listing numbers, especially by leveraging logarithmic scales and 3D graphs to effectively represent data with vast differences in size.

Why not visualize a variety of data in this way? Python and Matplotlib are really powerful tools. They'll help you uncover the stories behind your data. What interesting data can you visualize in 3D next? Let your imagination run wild!

Until next time, we'll be back with another fun topic. Bye! Oh, and by the way, what about the Korean numbering system? Click here to view the Expand your knowledge!