Ik heb gelezen over dubbele scalair, maar begrijp het maar gedeeltelijk. Voor zover ik weet, is dit het bereik dat beschikbaar is om door Numpy te worden berekend. Dat is de reden waarom de meeste vragen hier gericht zijn op de deling door nul (wat een fout is omdat het antwoord buiten bereik (oneindig) zal zijn).
Maar ik weet niet zeker of ik het goed heb begrepen. Ik zie ook geen andere oorzaken over RuntimeWarning:overflowdie zijn aangetroffen in double_scalars. Wat kan overflow veroorzaken in dubbele scalairen?
Antwoord 1, autoriteit 100%
Overloopfout houdt in dat een bewerking een waarde oplevert die buiten het bereik ligt dat is gedefinieerd voor het bijbehorende gegevenstype. Voor numpy double is dat bereik (-1.79769313486e+308, 1.79769313486e+308). Voor een goede discussie, lees dit SO-bericht.
Voorbeeld:
import numpy as np
np.seterr(all='warn')
print "Range of numpy double:", np.finfo(np.double).min, np.finfo(np.double).max
A = np.array([143],dtype='double')
a=A[-1]
print "At the border:", a**a
B = np.array([144],dtype='double')
b=B[-1]
print "Blowing out of range:", b**b
Uitvoer:
Range of numpy double: -1.79769313486e+308 1.79769313486e+308
At the border: 1.6332525973e+308
Blowing out of range: inf
D:\anaconda\lib\site-packages\ipykernel\__main__.py:9: RuntimeWarning: overflow encountered in double_scalars
Antwoord 2, autoriteit 44%
Een andere zeer populaire oorzaak van een RuntimeWarning:Overflow-ontmoeting is de floating point-fout. Voor meer informatie kun je hier
Hier volgen ook enkele definities van uitzonderingen met drijvende komma.
De drijvende-komma-uitzonderingen zijn gedefinieerd in de IEEE 754-standaard 1:
Delen door nul: oneindig resultaat verkregen uit eindige getallen.
Overloop: resultaat te groot om uit te drukken.
Underflow: resultaat zo dicht bij nul dat enige precisie verloren ging.
Ongeldige bewerking: resultaat is geen uitdrukbaar getal, geeft meestal aan dat er een NaN is geproduceerd.
Ik hoop dat dit helpt, veel succes.
Antwoord 3, autoriteit 33%
NumPy houdt zich aan de IEEE floating point-beperkingen. De kleinste tot de grootste representeerbare getallen in drijvende-kommaprecisie kunnen worden opgevraagd met numpy.finfo
In [35]: np.finfo(dtype=np.float64)
Out[35]: finfo(resolution=1e-15, min=-1.7976931348623157e+308, max=1.7976931348623157e+308, dtype=float64)
In [36]: np.finfo(dtype=np.float32)
Out[36]: finfo(resolution=1e-06, min=-3.4028235e+38, max=3.4028235e+38, dtype=float32)
Dus voor dubbele precisie, alle numpy-functies (zoals divide, exp, sqrt, ...) buiten het bereik ~[-1.797e+308, 1.797e+308]zal een overloopwaarschuwing geven.
Bijvoorbeeld:
In [37]: np.ones(1)/1e-308 # fine
Out[37]: array([ 1.00000000e+308])
In [38]: np.ones(1)/1e-309 # overflow
/usr/bin/ipython:1: RuntimeWarning: overflow encountered in divide
Out[38]: array([ inf])
In [39]: np.exp(1000.) # overflow
/usr/bin/ipython:1: RuntimeWarning: overflow encountered in exp
Out[39]: inf