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

Il blog di Biagio Raucci

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.

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.

- 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)
```

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.

- 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