En regardant en arrière sur 2015, je voudrais résumer les fonctions mathématiques que j'ai trouvées dans scipy.

scipy.stats.dirichlet C'est une fonction de la distribution Diricle utilisée dans LDA et ainsi de suite.

import numpy as np
import scipy.stats as ss
import matplotlib.pyplot as plt
import matplotlib.tri as tri

alphas = np.array([3.0, 4.0, 5.0])
dc = ss.dirichlet(alphas)

corners = np.array([[0.0, 0.0], [1.0, 0.0], [0.5, np.sqrt(3.0) / 2.0]])
midpoints = [(corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2.0 for i in range(3)]

def xy2bc(xy):
    s = [(corners[i] - midpoints[i]).dot(xy - midpoints[i]) / 0.75 for i in range(3)]
    return np.clip(s, 0.0, 1.0)
refiner = tri.UniformTriRefiner(tri.Triangulation(corners[:, 0], corners[:, 1]))
trimesh = refiner.refine_triangulation(subdiv=8)
pvals = [dc.pdf(xy2bc(xy)) for xy in zip(trimesh.x, trimesh.y)]
plt.tricontourf(trimesh, pvals, 200)
plt.axis('equal')
plt.show()

scipy.stats.wishert, scipy.stats.invwishert C'est aussi la distribution de Wishart et la distribution inverse de Wishart qui sont parfois utilisées dans MCMC. L'exemple suivant générera 10 nombres aléatoires pour chacune des matrices distribuées bidimensionnelles.

import numpy as np
import scipy.stats as ss

w = ss.wishart(df=3, scale=np.matrix([[1.0, 0.5], [0.5, 1.0]]))
print w.rvs(10)
iw = ss.invwishart(df=3, scale=np.matrix([[1.0, 0.5], [0.5, 1.0]]))
print iw.rvs(10)

scipy.special.comb, scipy.special.perm Calcul de séquence et de combinaison.

>>> import scipy.special as ss
>>> ss.comb(6, 3) # 6C3
20.0
>>> ss.perm(6, 3) # 6P3
120.0

scipy.optimize.rosen Fonction Rosenblock utilisée dans le cadre de l'optimisation.

from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import matplotlib.pyplot as plt

from scipy.optimize import rosen
import numpy as np

fig = plt.figure()
ax = fig.gca(projection='3d')
X, Y = np.meshgrid(np.arange(-3., 3., 0.1), np.arange(-3., 3., 0.1))
Z = [[rosen((x, y)) for x, y in zip(xx, yy)] for xx, yy in zip(X, Y)]
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)
plt.show()

scipy.signal.lti C'est un invariant de temps linéaire qui est pris en charge dans l'ingénierie de contrôle. Dans l'exemple ci-dessous, un système invariant dans le temps linéaire est créé et son diagramme de carte est dessiné.

import numpy as np
from scipy import signal
import matplotlib.pyplot as plt

# 1 / s^2 + 0.1s + 1
s = signal.lti([1], [1.0, 0.1, 1.0])
w, mag, phase = signal.bode(s, np.arange(0.1, 5.0, 0.01).tolist())

fig, (ax0, ax1) = plt.subplots(nrows=2, sharex=True)
ax0.semilogx(w, mag, 'b-')
ax0.set_ylabel("Magnitude")
ax1.semilogx(w, phase, 'r-')
ax1.set_ylabel("Phase")
plt.show()

scipy.spatial.KDTree C'est un arbre KD de l'algorithme de division spatiale. Dans l'exemple ci-dessous, les points sont dispersés dans une grille dans un espace tridimensionnel, et tous les points situés dans une plage de distance de 1,0 à partir des points (20, 20, 20) sont extraits.

import numpy as np
import scipy.spatial as ss                                      

x, y, z= np.mgrid[0:100, 0:100, 0:100]
points = zip(x.ravel(), y.ravel(), z.ravel())
tree = ss.KDTree(points)
a = tree.query_ball_point([20, 20, 20], 1.0)
print [points[i] for i in a]

[(19, 20, 20), (20, 19, 20), (20, 20, 19), (20, 20, 20), (20, 20, 21), (20, 21, 20), (21, 20, 20)]

scipy.cluster.vq.kmeans2 La méthode de k-moyennage pour les algorithmes de clustering.

import numpy
from scipy.cluster.vq import kmeans2, whiten

features = numpy.array([[ 1.9,2.3],
                        [ 1.5,2.5],
                        [ 0.8,0.6],
                        [ 0.4,1.8],
                        [ 0.1,0.1],
                        [ 0.2,1.8],
                        [ 2.0,0.5],
                        [ 0.3,1.5],
                        [ 1.0,1.0]])
wf = whiten(features)  #Normalisation
print kmeans2(wf, k=2)

Vous obtiendrez une étiquette pour le centre et chaque valeur.

(array([[ 1.40584568,  0.69587293],
       [ 1.24002799,  2.50514254]]), array([1, 1, 0, 1, 0, 1, 0, 1, 0]))

scipy.constants.g Ce n'est pas une fonction, mais c'est une accélération gravitationnelle. Divers autres paramètres physiques sont définis.

>>> import scipy.constants
>>> scipy.constants.g
9.80665

scipy.ndimage.gaussian_filter Un algorithme de filtre utilisé dans le traitement d'image.

import scipy
from scipy import ndimage
import matplotlib.pyplot as plt

img = scipy.misc.lena().astype(float)
fimg = ndimage.gaussian_filter(img, 3)

plt.figure(figsize=(8, 4))
plt.subplot(121)
plt.imshow(img, cmap=plt.cm.gray)
plt.subplot(122)
plt.imshow(fimg, cmap=plt.cm.gray)
plt.show()

Résumé

scipy implémente diverses fonctions et algorithmes dans divers domaines, et c'est amusant de simplement regarder la référence. Je vous serai également redevable l’année prochaine.

Fonctions mathématiques trouvées dans Scipy

Résumé