Python numpy 模块，double() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.double()。
def logp_trace(model):
"""
return a trace of logp for model
"""
#init
db = model.db
n_samples = db.trace('deviance').length()
logp = np.empty(n_samples, np.double)
#loop over all samples
for i_sample in range(n_samples):
#set the value of all stochastic to their 'i_sample' value
for stochastic in model.stochastics:
try:
value = db.trace(stochastic.__name__)[i_sample]
stochastic.value = value
except KeyError:
print("No trace available for %s. " % stochastic.__name__)
#get logp
logp[i_sample] = model.logp
return logp
def logp_trace(model):
"""
return a trace of logp for model
"""
#init
db = model.db
n_samples = db.trace('deviance').length()
logp = np.empty(n_samples, np.double)
#loop over all samples
for i_sample in range(n_samples):
#set the value of all stochastic to their 'i_sample' value
for stochastic in model.stochastics:
try:
value = db.trace(stochastic.__name__)[i_sample]
stochastic.value = value
except KeyError:
print("No trace available for %s. " % stochastic.__name__)
#get logp
logp[i_sample] = model.logp
return logp
def score_mod(gold, prediction, method):
"""
Computes correlation coefficient for two lists of values.
:param gold: list of gold values
:param prediction: list of predicted values
:param method: string, can be either of "pearson", "spearman" or "auc" (area under curve)
:return: correlation coefficient and p-value
"""
if len(gold) != len(prediction):
raise ValueError("The two arrays must have the same length!")
gold = np.array(gold, dtype=np.double)
prediction = np.array(prediction, dtype=np.double)
if method == "pearson":
return pearson(gold, prediction)
elif method == "spearman":
return spearman(gold, prediction)
elif method == "auc":
return auc(gold, prediction)
else:
raise NotImplementedError("Unknown scoring measure:%s" % method)
def test_basic(self):
dts = [np.bool, np.int16, np.int32, np.int64, np.double, np.complex128,
np.longdouble, np.clongdouble]
for dt in dts:
c = np.ones(53, dtype=np.bool)
assert_equal(np.where( c, dt(0), dt(1)), dt(0))
assert_equal(np.where(~c, dt(0), dt(1)), dt(1))
assert_equal(np.where(True, dt(0), dt(1)), dt(0))
assert_equal(np.where(False, dt(0), dt(1)), dt(1))
d = np.ones_like(c).astype(dt)
e = np.zeros_like(d)
r = d.astype(dt)
c[7] = False
r[7] = e[7]
assert_equal(np.where(c, e, e), e)
assert_equal(np.where(c, d, e), r)
assert_equal(np.where(c, d, e[0]), r)
assert_equal(np.where(c, d[0], e), r)
assert_equal(np.where(c[::2], d[::2], e[::2]), r[::2])
assert_equal(np.where(c[1::2], d[1::2], e[1::2]), r[1::2])
assert_equal(np.where(c[::3], d[::3], e[::3]), r[::3])
assert_equal(np.where(c[1::3], d[1::3], e[1::3]), r[1::3])
assert_equal(np.where(c[::-2], d[::-2], e[::-2]), r[::-2])
assert_equal(np.where(c[::-3], d[::-3], e[::-3]), r[::-3])
assert_equal(np.where(c[1::-3], d[1::-3], e[1::-3]), r[1::-3])
def do(self, a, b):
d = linalg.det(a)
(s, ld) = linalg.slogdet(a)
if asarray(a).dtype.type in (single, double):
ad = asarray(a).astype(double)
else:
ad = asarray(a).astype(cdouble)
ev = linalg.eigvals(ad)
assert_almost_equal(d, multiply.reduce(ev, axis=-1))
assert_almost_equal(s * np.exp(ld), multiply.reduce(ev, axis=-1))
s = np.atleast_1d(s)
ld = np.atleast_1d(ld)
m = (s != 0)
assert_almost_equal(np.abs(s[m]), 1)
assert_equal(ld[~m], -inf)
def test_UPLO(self):
Klo = np.array([[0, 0], [1, 0]], dtype=np.double)
Kup = np.array([[0, 1], [0, 0]], dtype=np.double)
tgt = np.array([-1, 1], dtype=np.double)
rtol = get_rtol(np.double)
# Check default is 'L'
w = np.linalg.eigvalsh(Klo)
assert_allclose(w, tgt, rtol=rtol)
# Check 'L'
w = np.linalg.eigvalsh(Klo, UPLO='L')
assert_allclose(w, tgt, rtol=rtol)
# Check 'l'
w = np.linalg.eigvalsh(Klo, UPLO='l')
assert_allclose(w, tgt, rtol=rtol)
# Check 'U'
w = np.linalg.eigvalsh(Kup, UPLO='U')
assert_allclose(w, tgt, rtol=rtol)
# Check 'u'
w = np.linalg.eigvalsh(Kup, UPLO='u')
assert_allclose(w, tgt, rtol=rtol)
def test_UPLO(self):
Klo = np.array([[0, 0], [1, 0]], dtype=np.double)
Kup = np.array([[0, 1], [0, 0]], dtype=np.double)
tgt = np.array([-1, 1], dtype=np.double)
rtol = get_rtol(np.double)
# Check default is 'L'
w, v = np.linalg.eigh(Klo)
assert_allclose(w, tgt, rtol=rtol)
# Check 'L'
w, v = np.linalg.eigh(Klo, UPLO='L')
assert_allclose(w, tgt, rtol=rtol)
# Check 'l'
w, v = np.linalg.eigh(Klo, UPLO='l')
assert_allclose(w, tgt, rtol=rtol)
# Check 'U'
w, v = np.linalg.eigh(Kup, UPLO='U')
assert_allclose(w, tgt, rtol=rtol)
# Check 'u'
w, v = np.linalg.eigh(Kup, UPLO='u')
assert_allclose(w, tgt, rtol=rtol)
def test_mode_raw(self):
# The factorization is not unique and varies between libraries,
# so it is not possible to check against known values. Functional
# testing is a possibility, but awaits the exposure of more
# of the functions in lapack_lite. Consequently, this test is
# very limited in scope. Note that the results are in FORTRAN
# order, hence the h arrays are transposed.
a = array([[1, 2], [3, 4], [5, 6]], dtype=np.double)
# Test double
h, tau = linalg.qr(a, mode='raw')
assert_(h.dtype == np.double)
assert_(tau.dtype == np.double)
assert_(h.shape == (2, 3))
assert_(tau.shape == (2,))
h, tau = linalg.qr(a.T, mode='raw')
assert_(h.dtype == np.double)
assert_(tau.dtype == np.double)
assert_(h.shape == (3, 2))
assert_(tau.shape == (2,))
def __init__(self, env, shape, clip=10.0, update_freq=100):
self.env = env
self.clip = clip
self.update_freq = update_freq
self.count = 0
self.sum = 0.0
self.sum_sqr = 0.0
self.mean = np.zeros(shape, dtype=np.double)
self.std = np.ones(shape, dtype=np.double)
def prepare_default(N=100, dtype=np.double):
return ( np.asarray(np.random.rand(N, N), dtype=dtype), )
#return toc/trials, (4/3)*N*N*N*1e-9, times
def prepare_eig(N=100, dtype=np.double):
N/=4
return ( np.asarray(np.random.rand(int(N), int(N)), dtype=dtype), )
def prepare_svd(N=100, dtype=np.double):
N/=2
return ( np.asarray(np.random.rand(int(N), int(N)), dtype=dtype), False )
#det: return toc/trials, N*N*N*1e-9, times
def prepare_dot(N=100, dtype=np.double):
N=N*N*10
A = np.asarray(np.random.rand(int(N)), dtype=dtype)
return (A, A)
#return 1.0*toc/(trials), 2*N*N*N*1e-9, times
def prepare_ivi(N=100, dtype=np.double):
A = np.random.rand(3260, 3260)
B = np.random.rand(3260, 3000)
return (A, B)
#return 1.0*toc/(trials), 2*N*N*N*1e-9, times
def prepare_cholesky(N=100, dtype=np.double):
N = int(N*2)
A = np.asarray(np.random.rand(N, N), dtype=dtype)
return ( A*A.transpose() + N*np.eye(N), )
#return toc/trials, N*N*N/3.0*1e-9, times
#inv: return toc/trials, 2*N*N*N*1e-9, times
##################################################################################
def TermProgress_nocb(*args, **kwargs):
"""TermProgress_nocb(double dfProgress, char const * pszMessage=None, void * pData=None) -> int"""
return _gdal_array.TermProgress_nocb(*args, **kwargs)
def BandRasterIONumPy(*args, **kwargs):
"""
BandRasterIONumPy(Band band, int bWrite, double xoff, double yoff, double xsize, double ysize, PyArrayObject * psArray,
int buf_type, GDALRIOResampleAlg resample_alg, GDALProgressFunc callback=0,
void * callback_data=None) -> CPLErr
"""
return _gdal_array.BandRasterIONumPy(*args, **kwargs)
def RATWriteArray(rat, array, field, start=0):
"""
Pure Python implementation of writing a chunk of the RAT
from a numpy array. Type of array is coerced to one of the types
(int, double, string) supported. Called from RasterAttributeTable.WriteArray
"""
if array is None:
raise ValueError("Expected array of dim 1")
# if not the array type convert it to handle lists etc
if not isinstance(array, numpy.ndarray):
array = numpy.array(array)
if array.ndim != 1:
raise ValueError("Expected array of dim 1")
if (start + array.size) > rat.GetRowCount():
raise ValueError("Array too big to fit into RAT from start position")
if numpy.issubdtype(array.dtype, numpy.integer):
# is some type of integer - coerce to standard int
# TODO: must check this is fine on all platforms
# confusingly numpy.int 64 bit even if native type 32 bit
array = array.astype(numpy.int32)
elif numpy.issubdtype(array.dtype, numpy.floating):
# is some type of floating point - coerce to double
array = array.astype(numpy.double)
elif numpy.issubdtype(array.dtype, numpy.character):
# cast away any kind of Unicode etc
array = array.astype(numpy.character)
else:
raise ValueError("Array not of a supported type (integer, double or string)")
return RATValuesIONumPyWrite(rat, field, start, array)
def test_signals_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
asig = AnalogSignal(signal=self.rquant((10, 3), pq.mV),
sampling_rate=pq.Quantity(10, "Hz"))
seg.analogsignals.append(asig)
self.write_and_compare([block])
anotherblock = Block("ir signal block")
seg = Segment("ir signal seg")
anotherblock.segments.append(seg)
irsig = IrregularlySampledSignal(
signal=np.random.random((20, 3)),
times=self.rquant(20, pq.ms, True),
units=pq.A
)
seg.irregularlysampledsignals.append(irsig)
self.write_and_compare([anotherblock])
block.segments[0].analogsignals.append(
AnalogSignal(signal=[10.0, 1.0, 3.0], units=pq.S,
sampling_period=pq.Quantity(3, "s"),
dtype=np.double, name="signal42",
description="this is an analogsignal",
t_start=45 * pq.ms),
)
self.write_and_compare([block, anotherblock])
block.segments[0].irregularlysampledsignals.append(
IrregularlySampledSignal(times=np.random.random(10),
signal=np.random.random((10, 3)),
units="mV", time_units="s",
dtype=np.float,
name="some sort of signal",
description="the signal is described")
)
self.write_and_compare([block, anotherblock])
def __read_comment(self):
"""
Read a single comment.
The comment is stored as an Event in Segment 0, which is
specifically for comments.
----------------------
Returns an empty list.
The returned object is already added to the Block.
No ID number: always called from another method
"""
# float64 -- timestamp (number of days since dec 30th 1899)
time = np.fromfile(self._fsrc, dtype=np.double, count=1)[0]
# int16 -- length of next string
numchars1 = np.asscalar(np.fromfile(self._fsrc,
dtype=np.int16, count=1))
# char * numchars -- the one who sent the comment
sender = self.__read_str(numchars1)
# int16 -- length of next string
numchars2 = np.asscalar(np.fromfile(self._fsrc,
dtype=np.int16, count=1))
# char * numchars -- comment text
text = self.__read_str(numchars2, utf=False)
comment = Event(times=pq.Quantity(time, units=pq.d), labels=text,
sender=sender, file_origin=self._file_origin)
self._seg0.events.append(comment)
return []
def __read_spiketrain_timestamped(self):
"""
Read a SpikeTrain
This SpikeTrain contains a time stamp for when it was recorded
The timestamp is stored as an annotation in the SpikeTrain.
-------------------------------------------------
Returns a SpikeTrain object with multiple spikes.
The returned object must be added to the Block.
ID: 29110
"""
# float64 -- timeStamp (number of days since dec 30th 1899)
timestamp = np.fromfile(self._fsrc, dtype=np.double, count=1)[0]
# convert to datetime object
timestamp = self._convert_timestamp(timestamp)
# seq_list -- spike list
# combine the spikes into a single SpikeTrain
spiketrain = self._combine_spiketrains(self.__read_list())
# add the timestamp
spiketrain.annotations['timestamp'] = timestamp
return spiketrain
def __read_unit_list_timestamped(self):
"""
A list of a list of Units.
This is the same as __read_unit_list, except that it also has a
timestamp. This is added ad an annotation to all Units.
-----------------------------------------------
Returns a list of Units modified in the method.
The returned objects are already added to the Block.
ID: 29119
"""
# double -- time zero (number of days since dec 30th 1899)
timestamp = np.fromfile(self._fsrc, dtype=np.double, count=1)[0]
# convert to to days since UNIX epoc time:
timestamp = self._convert_timestamp(timestamp)
# sorter -- this is based off a sorter
units = self.__read_unit_list()
for unit in units:
unit.annotations['timestamp'].append(timestamp)
return units
def test_signals_write(self):
block = Block()
seg = Segment()
block.segments.append(seg)
asig = AnalogSignal(signal=self.rquant((10, 3), pq.mV),
sampling_rate=pq.Quantity(10, "Hz"))
seg.analogsignals.append(asig)
self.write_and_compare([block])
anotherblock = Block("ir signal block")
seg = Segment("ir signal seg")
anotherblock.segments.append(seg)
irsig = IrregularlySampledSignal(
signal=np.random.random((20, 3)),
times=self.rquant(20, pq.ms, True),
units=pq.A
)
seg.irregularlysampledsignals.append(irsig)
self.write_and_compare([anotherblock])
block.segments[0].analogsignals.append(
AnalogSignal(signal=[10.0, 1.0, 3.0], units=pq.S,
sampling_period=pq.Quantity(3, "s"),
dtype=np.double, name="signal42",
description="this is an analogsignal",
t_start=45 * pq.ms),
)
self.write_and_compare([block, anotherblock])
block.segments[0].irregularlysampledsignals.append(
IrregularlySampledSignal(times=np.random.random(10),
signal=np.random.random((10, 3)),
units="mV", time_units="s",
dtype=np.float,
name="some sort of signal",
description="the signal is described")
)
self.write_and_compare([block, anotherblock])
def __read_spiketrain_timestamped(self):
"""
Read a SpikeTrain
This SpikeTrain contains a time stamp for when it was recorded
The timestamp is stored as an annotation in the SpikeTrain.
-------------------------------------------------
Returns a SpikeTrain object with multiple spikes.
The returned object must be added to the Block.
ID: 29110
"""
# float64 -- timeStamp (number of days since dec 30th 1899)
timestamp = np.fromfile(self._fsrc, dtype=np.double, count=1)[0]
# convert to datetime object
timestamp = self._convert_timestamp(timestamp)
# seq_list -- spike list
# combine the spikes into a single SpikeTrain
spiketrain = self._combine_spiketrains(self.__read_list())
# add the timestamp
spiketrain.annotations['timestamp'] = timestamp
return spiketrain
def __read_unit_list_timestamped(self):
"""
A list of a list of Units.
This is the same as __read_unit_list, except that it also has a
timestamp. This is added ad an annotation to all Units.
-----------------------------------------------
Returns a list of Units modified in the method.
The returned objects are already added to the Block.
ID: 29119
"""
# double -- time zero (number of days since dec 30th 1899)
timestamp = np.fromfile(self._fsrc, dtype=np.double, count=1)[0]
# convert to to days since UNIX epoc time:
timestamp = self._convert_timestamp(timestamp)
# sorter -- this is based off a sorter
units = self.__read_unit_list()
for unit in units:
unit.annotations['timestamp'].append(timestamp)
return units
def computeallcpus(self):
""" overall stats for all cores on the nodes """
ratios = numpy.empty((self._ncpumetrics, self._totalcores), numpy.double)
coreindex = 0
for host, last in self._last.iteritems():
try:
elapsed = last - self._first[host]
if numpy.amin(numpy.sum(elapsed, 0)) < 1.0:
# typically happens if the job was very short and the datapoints are too close together
return {"error": ProcessingError.JOB_TOO_SHORT}
coresperhost = len(last[0, :])
ratios[:, coreindex:(coreindex+coresperhost)] = 1.0 * elapsed / numpy.sum(elapsed, 0)
coreindex += coresperhost
except ValueError:
# typically happens if the linux pmda crashes during the job
return {"error": ProcessingError.INSUFFICIENT_DATA}
results = {}
for i, name in enumerate(self._outnames):
results[name] = calculate_stats(ratios[i, :])
results['all'] = {"cnt": self._totalcores}
return results
def computejobcpus(self):
""" stats for the cores on the nodes that were assigend to the job (if available) """
proc = self._job.getdata('proc')
if proc == None:
return {"error": ProcessingError.CPUSET_UNKNOWN}, {"error": ProcessingError.CPUSET_UNKNOWN}
cpusallowed = self._job.getdata('proc')['cpusallowed']
ratios = numpy.empty((self._ncpumetrics, self._totalcores), numpy.double)
coreindex = 0
for host, last in self._last.iteritems():
elapsed = last - self._first[host]
if host in cpusallowed and 'error' not in cpusallowed[host]:
elapsed = elapsed[:, cpusallowed[host]]
else:
return {"error": ProcessingError.CPUSET_UNKNOWN}, {"error": ProcessingError.CPUSET_UNKNOWN}
coresperhost = len(elapsed[0, :])
ratios[:, coreindex:(coreindex+coresperhost)] = 1.0 * elapsed / numpy.sum(elapsed, 0)
coreindex += coresperhost
allowedcores = numpy.array(ratios[:, :coreindex])
results = {}
for i, name in enumerate(self._outnames):
results[name] = calculate_stats(allowedcores[i, :])
results['all'] = {"cnt": coreindex}
effective = numpy.compress(allowedcores[1, :] < 0.95, allowedcores , axis=1)
effectiveresults = {
'all': len(effective[i, :])
}
if effectiveresults['all'] > 0:
for i, name in enumerate(self._outnames):
effectiveresults[name] = calculate_stats(effective[i, :])
return results, effectiveresults
def quantize_data(x, y, wc=None, continuous_rate=0.1, separate=False):
if isinstance(x, list):
xt = map(list, zip(*x))
else:
xt = x.T
features = [set(feat) for feat in xt]
if wc is None:
wc = np.array([len(feat) >= int(continuous_rate * len(y)) for feat in features])
else:
wc = np.asarray(wc)
feat_dics = [{_l: i for i, _l in enumerate(feats)} if not wc[i] else None
for i, feats in enumerate(features)]
if not separate:
if np.all(~wc):
dtype = np.int
else:
dtype = np.double
x = np.array([[feat_dics[i][_l] if not wc[i] else _l for i, _l in enumerate(sample)]
for sample in x], dtype=dtype)
else:
x = np.array([[feat_dics[i][_l] if not wc[i] else _l for i, _l in enumerate(sample)]
for sample in x], dtype=np.double)
x = (x[:, ~wc].astype(np.int), x[:, wc])
label_dic = {_l: i for i, _l in enumerate(set(y))}
y = np.array([label_dic[yy] for yy in y], dtype=np.int8)
label_dic = {i: _l for _l, i in label_dic.items()}
return x, y, wc, features, feat_dics, label_dic
def test_element_size(self):
byte = torch.ByteStorage().element_size()
char = torch.CharStorage().element_size()
short = torch.ShortStorage().element_size()
int = torch.IntStorage().element_size()
long = torch.LongStorage().element_size()
float = torch.FloatStorage().element_size()
double = torch.DoubleStorage().element_size()
self.assertEqual(byte, torch.ByteTensor().element_size())
self.assertEqual(char, torch.CharTensor().element_size())
self.assertEqual(short, torch.ShortTensor().element_size())
self.assertEqual(int, torch.IntTensor().element_size())
self.assertEqual(long, torch.LongTensor().element_size())
self.assertEqual(float, torch.FloatTensor().element_size())
self.assertEqual(double, torch.DoubleTensor().element_size())
self.assertGreater(byte, 0)
self.assertGreater(char, 0)
self.assertGreater(short, 0)
self.assertGreater(int, 0)
self.assertGreater(long, 0)
self.assertGreater(float, 0)
self.assertGreater(double, 0)
# These tests are portable, not necessarily strict for your system.
self.assertEqual(byte, 1)
self.assertEqual(char, 1)
self.assertGreaterEqual(short, 2)
self.assertGreaterEqual(int, 2)
self.assertGreaterEqual(int, short)
self.assertGreaterEqual(long, 4)
self.assertGreaterEqual(long, int)
self.assertGreaterEqual(double, float)
def test_from_numpy(self):
dtypes = [
np.double,
np.float,
np.int64,
np.int32,
np.uint8
]
for dtype in dtypes:
array = np.array([1, 2, 3, 4], dtype=dtype)
self.assertEqual(torch.from_numpy(array), torch.Tensor([1, 2, 3, 4]))
def box_to_affine(xc, yc, angle, scalex, aspect):
m = np.zeros((2, 3), np.double )
m[0,0] = scalex * math.cos(angle)
m[1,0] = scalex * math.sin(angle)
m[0,1] = - scalex * math.sin(angle) * aspect
m[1,1] = scalex * math.cos(angle) * aspect
m[0,2] = xc
m[1,2] = yc
return m
def from_pb_tile(tile, no_data_value=None, data_type=None):
"""Creates a ``Tile`` from ``ProtoTile``.
Args:
tile (ProtoTile): The ``ProtoTile`` instance to be converted.
Returns:
:class:`~geopyspark.geotrellis.Tile`
"""
if not data_type:
data_type = _mapped_data_types[tile.cellType.dataType]
if data_type == 'BIT':
cells = np.int8(tile.uint32Cells[:])
elif data_type == 'BYTE':
cells = np.int8(tile.sint32Cells[:])
elif data_type == 'UBYTE':
cells = np.uint8(tile.uint32Cells[:])
elif data_type == 'SHORT':
cells = np.int16(tile.sint32Cells[:])
elif data_type == 'USHORT':
cells = np.uint16(tile.uint32Cells[:])
elif data_type == 'INT':
cells = np.int32(tile.sint32Cells[:])
elif data_type == 'FLOAT':
cells = np.float32(tile.floatCells[:])
else:
cells = np.double(tile.doubleCells[:])
return cells.reshape(tile.rows, tile.cols)
def get_coef(self, X):
qr, qraux = self.qr, self.qraux
n, p = qr.shape
# sanity check
assert isinstance(qr, np.ndarray), 'internal error: QR should be a np.ndarray but got %s' % type(qr)
assert isinstance(qraux, np.ndarray), 'internal error: qraux should be a np.ndarray but got %s' % type(qraux)
# validate input array
X = check_array(X, dtype='numeric', copy=True, order='F')
nx, ny = X.shape
if nx != n:
raise ValueError('qr and X must have same number of rows')
# check on size
_validate_matrix_size(n, p)
# get the rank of the decomposition
k = self.rank
# get ix vector
# if p > n:
# ix = np.ones(n + (p - n)) * np.nan
# ix[:n] = np.arange(n) # i.e., array([0,1,2,nan,nan,nan])
# else:
# ix = np.arange(n)
# set up the structures to alter
coef, info = (np.zeros((k, ny), dtype=np.double, order='F'),
np.zeros(1, dtype=np.int, order='F'))
# call the fortran module IN PLACE
_safecall(dqrsl.dqrcf, qr, n, k, qraux, X, ny, coef, 0)
# post-processing
# if k < p:
# cf = np.ones((p,ny)) * np.nan
# cf[self.pivot[np.arange(k)], :] = coef
return coef if not k < p else coef[self.pivot[np.arange(k)], :]
def _prep_X_Y_for_cython(X, Y):
X, Y = check_pairwise_arrays(X, Y)
X, Y = X.astype(np.double, order='C'), Y.astype(np.double, order='C').T # transposing Y here!
res = np.zeros((X.shape[0], Y.shape[1]), dtype=X.dtype)
return X, Y, res
# Cython proxies
def _hilbert_dot(x, y, scalar=1.0):
# return ``2 * safe_sparse_dot(x, y) - safe_sparse_dot(x, x.T) - safe_sparse_dot(y, y.T)``
x, y = x.astype(np.double, order='C'), y.astype(np.double, order='C')
return _hilbert_dot_fast(x, y, scalar)
def _hilbert_matrix(X, Y=None, scalar=1.0):
X, Y, res = _prep_X_Y_for_cython(X, Y)
_hilbert_matrix_fast(X, Y, res, np.double(scalar))
return res
def test_floats_from_string(self, level=rlevel):
# Ticket #640, floats from string
fsingle = np.single('1.234')
fdouble = np.double('1.234')
flongdouble = np.longdouble('1.234')
assert_almost_equal(fsingle, 1.234)
assert_almost_equal(fdouble, 1.234)
assert_almost_equal(flongdouble, 1.234)
def test_byteswap_complex_scalar(self):
# Ticket #1259 and gh-441
for dtype in [np.dtype('<'+t) for t in np.typecodes['Complex']]:
z = np.array([2.2-1.1j], dtype)
x = z[0] # always native-endian
y = x.byteswap()
if x.dtype.byteorder == z.dtype.byteorder:
# little-endian machine
assert_equal(x, np.fromstring(y.tobytes(), dtype=dtype.newbyteorder()))
else:
# big-endian machine
assert_equal(x, np.fromstring(y.tobytes(), dtype=dtype))
# double check real and imaginary parts:
assert_equal(x.real, y.real.byteswap())
assert_equal(x.imag, y.imag.byteswap())
def test_float_types():
""" Check formatting.
This is only for the str function, and only for simple types.
The precision of np.float and np.longdouble aren't the same as the
python float precision.
"""
for t in [np.float32, np.double, np.longdouble]:
yield check_float_type, t
def test_nan_inf_float():
""" Check formatting of nan & inf.
This is only for the str function, and only for simple types.
The precision of np.float and np.longdouble aren't the same as the
python float precision.
"""
for t in [np.float32, np.double, np.longdouble]:
yield check_nan_inf_float, t
def test_float_type_print():
"""Check formatting when using print """
for t in [np.float32, np.double, np.longdouble]:
yield check_float_type_print, t
def test_export_record(self):
dt = [('a', 'b'),
('b', 'h'),
('c', 'i'),
('d', 'l'),
('dx', 'q'),
('e', 'B'),
('f', 'H'),
('g', 'I'),
('h', 'L'),
('hx', 'Q'),
('i', np.single),
('j', np.double),
('k', np.longdouble),
('ix', np.csingle),
('jx', np.cdouble),
('kx', np.clongdouble),
('l', 'S4'),
('m', 'U4'),
('n', 'V3'),
('o', '?'),
('p', np.half),
]
x = np.array(
[(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
asbytes('aaaa'), 'bbbb', asbytes(' '), True, 1.0)],
dtype=dt)
y = memoryview(x)
assert_equal(y.shape, (1,))
assert_equal(y.ndim, 1)
assert_equal(y.suboffsets, EMPTY)
sz = sum([np.dtype(b).itemsize for a, b in dt])
if np.dtype('l').itemsize == 4:
assert_equal(y.format, 'T{b:a:=h:b:i:c:l:d:q:dx:B:e:@H:f:=I:g:L:h:Q:hx:f:i:d:j:^g:k:=Zf:ix:Zd:jx:^Zg:kx:4s:l:=4w:m:3x:n:?:o:@e:p:}')
else:
assert_equal(y.format, 'T{b:a:=h:b:i:c:q:d:q:dx:B:e:@H:f:=I:g:Q:h:Q:hx:f:i:d:j:^g:k:=Zf:ix:Zd:jx:^Zg:kx:4s:l:=4w:m:3x:n:?:o:@e:p:}')
# Cannot test if NPY_RELAXED_STRIDES_CHECKING changes the strides
if not (np.ones(1).strides[0] == np.iinfo(np.intp).max):
assert_equal(y.strides, (sz,))
assert_equal(y.itemsize, sz)
def test_1darray(self):
array = np.arange(24, dtype=np.double)
from_c = test_as_c_array(array, 3)
assert_equal(array[3], from_c)
def test_2darray(self):
array = np.arange(24, dtype=np.double).reshape(3, 8)
from_c = test_as_c_array(array, 2, 4)
assert_equal(array[2, 4], from_c)
def test_3darray(self):
array = np.arange(24, dtype=np.double).reshape(2, 3, 4)
from_c = test_as_c_array(array, 1, 2, 3)
assert_equal(array[1, 2, 3], from_c)
def test_matrix_multiply(self):
self.compare_matrix_multiply_results(np.long)
self.compare_matrix_multiply_results(np.double)
def test_float_repr(self):
# long double test cannot work, because eval goes through a python
# float
for t in [np.float32, np.float64]:
yield self._test_type_repr, t
def mirr(values, finance_rate, reinvest_rate):
"""
Modified internal rate of return.
Parameters
----------
values : array_like
Cash flows (must contain at least one positive and one negative
value) or nan is returned. The first value is considered a sunk
cost at time zero.
finance_rate : scalar
Interest rate paid on the cash flows
reinvest_rate : scalar
Interest rate received on the cash flows upon reinvestment
Returns
-------
out : float
Modified internal rate of return
"""
values = np.asarray(values, dtype=np.double)
n = values.size
pos = values > 0
neg = values < 0
if not (pos.any() and neg.any()):
return np.nan
numer = np.abs(npv(reinvest_rate, values*pos))
denom = np.abs(npv(finance_rate, values*neg))
return (numer/denom)**(1.0/(n - 1))*(1 + reinvest_rate) - 1
def test_right_left_behavior(self):
# Needs range of sizes to test different code paths.
# size ==1 is special cased, 1 < size < 5 is linear search, and
# size >= 5 goes through local search and possibly binary search.
for size in range(1, 10):
xp = np.arange(size, dtype=np.double)
yp = np.ones(size, dtype=np.double)
incpts = np.array([-1, 0, size - 1, size], dtype=np.double)
decpts = incpts[::-1]
incres = interp(incpts, xp, yp)
decres = interp(decpts, xp, yp)
inctgt = np.array([1, 1, 1, 1], dtype=np.float)
dectgt = inctgt[::-1]
assert_equal(incres, inctgt)
assert_equal(decres, dectgt)
incres = interp(incpts, xp, yp, left=0)
decres = interp(decpts, xp, yp, left=0)
inctgt = np.array([0, 1, 1, 1], dtype=np.float)
dectgt = inctgt[::-1]
assert_equal(incres, inctgt)
assert_equal(decres, dectgt)
incres = interp(incpts, xp, yp, right=2)
decres = interp(decpts, xp, yp, right=2)
inctgt = np.array([1, 1, 1, 2], dtype=np.float)
dectgt = inctgt[::-1]
assert_equal(incres, inctgt)
assert_equal(decres, dectgt)
incres = interp(incpts, xp, yp, left=0, right=2)
decres = interp(decpts, xp, yp, left=0, right=2)
inctgt = np.array([0, 1, 1, 2], dtype=np.float)
dectgt = inctgt[::-1]
assert_equal(incres, inctgt)
assert_equal(decres, dectgt)