Diary

If you want to master something, teach it. The more you teach, the better you learn. Teaching is a powerful tool to learning.

– Richard Feynman

Una semplice calcolatrice del BMI (Indice di Massa Corporea) in PyQt… Qui il codice sorgente.

Chalkboards are a major part of my life. I couldn’t live without them

Math is beautiful, and the software we have at our fingertips represents an invaluable way to explore that beauty. Never before have we been able to visualize and experiment with mathematical objects in such an accessible way.

In this short tutorial I would like to break down the steps required to plot a function of two variables using Python.

Along the way, we’ll learn about a few NumPy procedures that’ll have you manipulating matrices like a wizard. I’ve broken the process down into three conceptual steps that’ll also help refresh the underlying math.

Finally, I put everything together into a function you can use out of the box, so feel free to skip to that if it’s all you need.

Define the Function Domain

A mathematical function is a map that takes elements from one set and associates them with one element of another set. This first set of inputs is called the domain of the function. In our case, the domain will consist of tuples of real numbers.

Although there are infinitely many real numbers inside any interval, we obviously can’t store an infinite set for our domain. For our plot to look nice, it’s sufficient to sample enough points within our domain so the end product will look smooth and not unnaturally jagged.

With this in mind, we can define our domain and store it in a set of arrays in three steps.

1. Decide on the boundaries for each of the two variables in our domain:

x_interval = (-2, 2)
y_interval = (-2, 2)

2. Sample points within each of these intervals:

x_points = np.linspace(x_interval[0], x_interval[1], 100)
y_points = np.linspace(y_interval[0], y_interval[1], 100)

3. Take the Cartesian product of these two sampled sets to produce two arrays that (when stacked) form a set of ordered pairs we can compute a function on:

X, Y = np.meshgrid(x_points, y_points)

The next step is to associate an output value with every point in our input domain. For the purpose, we define our math function as a Python function of two scalar inputs:

def func3d(x, y):
    return -np.sin(10 * (x**2 + y**2)) / 10

Then we produce a vectorized version of the function that can be called on vectors or matrices of inputs:

func3d_vectorized = np.vectorize(func3d)

Plot the Function

From this point, things proceed in nearly the same way as they would in making a 2D plot with Matplotlib. Only a few argument and method names need to change in order to produce beautiful 3D visualizations.

1. Set up a plotting figure and axes with projection='3d':

plt.figure(figsize=(20, 10))
ax = plt.axes(projection=’3d’)

2. Select a plotting method of the axes object and call it on our function data:

ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
                cmap=’terrain’, edgecolor=None)

3. Set other attributes of the plot, such as the title and axis labels:

ax.set(xlabel=”x”, ylabel=”y”, zlabel=”f(x, y)”, 
       title=”Cool Function”)

To make the process more reproducible, I’ve packaged all these steps together into a Python function for producing quick surface plots.

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

def plot_surface(domain, fn, grid_samples=100, title=None, **plot_kwargs):
    x = np.linspace(domain[0][0], domain[0][1], grid_samples)
    y = np.linspace(domain[1][0], domain[1][1], grid_samples)
    
    X, Y = np.meshgrid(x, y)
    
    fn_vectorized = np.vectorize(fn)
    Z = fn_vectorized(X, Y)
    
    fig = plt.figure(figsize=(20,10))
    ax = plt.axes(projection="3d")
    ax.plot_surface(X, Y, Z, **plot_kwargs)
    ax.set(xlabel="x", ylabel="y", zlabel="f(x, y)", title=title)
    plt.show()

    return fig, ax

# now let's try it out!
def func(x, y):
    return -np.sin(10 * (x**2 + y**2)) / 10
    
domain = [(-0.5, 0.5), (-0.5, 0.5)] 
fig, ax = plot_surface(domain, func, rstride=1, cstride=1, cmap='terrain', edgecolor=None)

In the following lines, we will learn how to create a simple dictionary in a few lines of Python code. First, we need the translate package.

translate is a simple but powerful translation tool written in Python with support for multiple translation providers. It offers integration with Microsoft Translation API, MyMemory API, LibreTranslate, and DeepL’s free and professional APIs.

We can use translate as a module with this command:

$ pip install translate

Now we create some codes that allow us to enter what we have to translate. We will write the following method pB_traducoClick():

    def pB_traducoClick(self):

        try:
            to_Translate = (self.lE_input.text())
            traduzione = t.Translator(to_lang="it")
            result = traduzione.translate(to_Translate)
            self.lE_output.setText(result)

        except:
            print('Valore nel campo non accettato')

This is the connection diagram:

The value of to_lang is one of the languages that are available in ISO_639–1 (like “en”, “ja”, “ko”, “pt”, “zh”, “zh-TW”, etc.)

You can choose in this document the language you want.

The result:

From here you can find the source codes.

The Gauss–Legendre algorithm is an algorithm to compute the digits of \(\pi\). It is notable for being rapidly convergent, with only 25 iterations producing 45 million correct digits of \(\pi\).

It repeatedly replaces two numbers (a e b, say) by their arithmetic and geometric means,

\(\frac{{a + b}}{2}{\text{ e }}\sqrt {ab}\)

in order to find their arithmetic-geometric mean.

The algorithm is quite simple, and is described here. Below you can find a Python code for implementing the algorithm, making use of the decimal module:

#!/usr/bin/env python
from __future__ import with_statement
import decimal

def pi_gauss_legendre():
    D = decimal.Decimal
    with decimal.localcontext() as ctx:
        ctx.prec += 2                
        a, b, t, p = 1, 1/D(2).sqrt(), 1/D(4), 1                
        pi = None
        while 1:
            an    = (a + b) / 2
            b     = (a * b).sqrt()
            t    -= p * (a - an) * (a - an)
            a, p  = an, 2*p
            piold = pi
            pi    = (a + b) * (a + b) / (4 * t)
            if pi == piold:  # equal within given precision
                break
    return +pi

decimal.getcontext().prec = 4500
print (pi_gauss_legendre())

This is a screen of output:

Noi atei crediamo di dover agire secondo coscienza per un principio morale, non perché ci aspettiamo una ricompensa in Paradiso.

– Margherita Hack