La réponse

np.sin sera en général aussi précise que possible, compte tenu de la précision du double (ie float ) variables dans lesquelles les valeurs d'entrée, de sortie et intermédiaires sont stockées. Vous pouvez obtenir une mesure raisonnable de la précision de np.sin en la comparant à la version de précision arbitraire de sin à partir de mpmath : p >

import matplotlib.pyplot as plt
import numpy as np
import scipy.optimize as spo

eps = 1e-4

def func(x, a):
    return a*np.sin(x) - x

def uniqueflt(arr):
    b = arr.copy()
    b.sort()
    d = np.append(True, np.diff(b))
    return b[d>eps]

initial_guess = np.arange(-9, 9) + eps
# uniqueflt removes any repeated roots
roots = uniqueflt(spo.fsolve(func, initial_guess, args=(10,)))
# roots is an array with the 7 unique roots of 10*np.sin(x) - x == 0:
#     array([-8.42320394e+00, -7.06817437e+00, -2.85234190e+00, -8.13413225e-09,
#            2.85234189e+00,  7.06817436e+00,  8.42320394e+00])

x = np.linspace(-20, 20, num=int(1e3))
plt.plot(x, x, label=r'$y = x$')
plt.plot(x, 10*np.sin(x), label=r'$y = 10 \cdot sin(x)$')
plt.plot(roots, 10*np.sin(roots), '.', c='k', ms=7, label='Solutions')

plt.ylim(-10.5, 20)
plt.gca().set_aspect('equal', adjustable='box')
plt.legend()

Sortie:

Ainsi, il est raisonnable de dire que les deux les erreurs relatives et absolues de np.sin ont une limite supérieure de 2e-16.

Une meilleure réponse

Il y a un excellente chance que si vous faites un incrément suffisamment petit pour que votre approche soit précise, votre algorithme sera trop lent pour une utilisation pratique. Les approches de résolution d'équations standard ne fonctionneront pas pour vous, car vous n'avez pas de fonction standard. Au lieu de cela, vous avez une fonction implicite à valeurs multiples. Voici un aperçu d'une approche générale pour obtenir toutes les solutions à ce type d'équation:

import matplotlib.pyplot as plt
import mpmath
from mpmath import mp

# set mpmath to an extremely high precision
mp.dps = 100
x = np.linspace(-np.pi, np.pi, num=int(1e3))

# numpy sine values
y = np.sin(x)

# extremely high precision sine values
realy = np.array([mpmath.sin(a) for a in x])

# the end results are arrays of arbitrary precision mpf values (ie abserr.dtype=='O')
diff = realy - y
abserr = np.abs(diff)
relerr = np.abs(diff/realy)

plt.plot(x, abserr, lw=.5, label='Absolute error')
plt.plot(x, relerr, lw=.5, label='Relative error')
plt.axhline(2e-16, c='k', ls='--', lw=.5, label=r'$2 \cdot 10^{-16}$')
plt.yscale('log')
plt.xlim(-np.pi, np.pi)
plt.ylim(1e-20, 1e-15)
plt.xlabel('x')
plt.ylabel('Error in np.sin(x)')
plt.legend()

Résultat:

Vous devrez modifier le initial_guess en fonction de votre valeur de a . initial_guess doit être au moins aussi grand que le nombre réel de solutions.

Un moyen simple d'estimer la précision de sin () ET cos () pour un argument donné x serait:

2*eps*(sin(x)+cos(x)) = 1 - sin(x)**2 - cos(x)**2

Vous voudrez peut-être supprimer le dernier 2 juste pour être du "bon côté" (enfin, il y a des valeurs de x pour lesquelles cette approximation ne tient pas très bien, en particulier pour x proche de -90 deg ). Je suggérerais de tester à environ x=pi/4

Explication :

L'idée de base derrière cette approche est la suivante ... Disons que notre sin (x) et cos (x) s'écarte des valeurs exactes par une seule "valeur d'erreur" eps . Autrement dit, exact_sin (x) = sin (x) + eps (idem pour cos (x) ). Appelons également delta pour être l'écart mesuré par rapport à l ' identité trigonométrique pythagoricienne a>:

1 - (sin(x) + eps)**2 - (cos(x) + eps)**2 == 0 =>
1 - sin(x)**2 - cos(x)**2 = delta = 2*eps*(sin(x) + cos(x)) + 2*eps**2

Pour les fonctions exactes, delta doit être zéro:

1 - exact_sin(x)**2 - exact_cos(x)**2 == 0

ou , aller à des fonctions inexactes:

delta = 1 - sin(x)**2 - cos(x)**2

Négliger le dernier terme 2 * eps ** 2 (supposer de petites erreurs):

eps_trig = np.abs(1 - (np.sin(x)**2 + np.cos(x)**2)) / 2

Si nous choisissons x de telle sorte que sin (x) + cos (x) plane autour de 1 (ou, quelque part dans la plage 0.5-2 ), nous pouvons estimer grossièrement que eps = | 1 - sin (x) ** 2 - cos (x) ** 2 | / 2 .