python integer_Python numpy.integer() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def pack_samples(self, samples, dtype=None):

"""Pack samples into one integer per sample

Store one sample in a single integer instead of a list of

integers with length `len(self.nsoutdims)`. Example:

>>> p = pauli_mpp(nr_sites=2, local_dim=2)

>>> p.outdims

(6, 6)

>>> p.pack_samples(np.array([[0, 1], [1, 0], [1, 2], [5, 5]]))

array([ 1, 6, 8, 35])

"""

assert samples.ndim == 2

assert samples.shape[1] == len(self.nsoutdims)

samples = np.ravel_multi_index(samples.T, self.nsoutdims)

if dtype not in (True, False, None) and issubclass(dtype, np.integer):

info = np.iinfo(dtype)

assert samples.min() >= info.min

assert samples.max() <= info.max

samples = samples.astype(dtype)

return samples

Example 2

def __init__(self, config, model_dir, ob_shape_list):

self.model_dir = model_dir

self.cnn_format = config.cnn_format

self.memory_size = config.memory_size

self.actions = np.empty(self.memory_size, dtype = np.uint8)

self.rewards = np.empty(self.memory_size, dtype = np.integer)

# print(self.memory_size, config.screen_height, config.screen_width)

# self.screens = np.empty((self.memory_size, config.screen_height, config.screen_width), dtype = np.float16)

self.screens = np.empty([self.memory_size] + ob_shape_list, dtype = np.float16)

self.terminals = np.empty(self.memory_size, dtype = np.bool)

self.history_length = config.history_length

# self.dims = (config.screen_height, config.screen_width)

self.dims = tuple(ob_shape_list)

self.batch_size = config.batch_size

self.count = 0

self.current = 0

# pre-allocate prestates and poststates for minibatch

self.prestates = np.empty((self.batch_size, self.history_length) + self.dims, dtype = np.float16)

self.poststates = np.empty((self.batch_size, self.history_length) + self.dims, dtype = np.float16)

# self.prestates = np.empty((self.batch_size, self.history_length, self.dims), dtype = np.float16)

# self.poststates = np.empty((self.batch_size, self.history_length, self.dims), dtype = np.float16)

Example 3

def test_auto_dtype_largeint(self):

# Regression test for numpy/numpy#5635 whereby large integers could

# cause OverflowErrors.

# Test the automatic definition of the output dtype

#

# 2**66 = 73786976294838206464 => should convert to float

# 2**34 = 17179869184 => should convert to int64

# 2**10 = 1024 => should convert to int (int32 on 32-bit systems,

# int64 on 64-bit systems)

data = TextIO('73786976294838206464 17179869184 1024')

test = np.ndfromtxt(data, dtype=None)

assert_equal(test.dtype.names, ['f0', 'f1', 'f2'])

assert_(test.dtype['f0'] == np.float)

assert_(test.dtype['f1'] == np.int64)

assert_(test.dtype['f2'] == np.integer)

assert_allclose(test['f0'], 73786976294838206464.)

assert_equal(test['f1'], 17179869184)

assert_equal(test['f2'], 1024)

Example 4

def test_with_incorrect_minlength(self):

x = np.array([], dtype=int)

assert_raises_regex(TypeError, "an integer is required",

lambda: np.bincount(x, minlength="foobar"))

assert_raises_regex(ValueError, "must be positive",

lambda: np.bincount(x, minlength=-1))

assert_raises_regex(ValueError, "must be positive",

lambda: np.bincount(x, minlength=0))

x = np.arange(5)

assert_raises_regex(TypeError, "an integer is required",

lambda: np.bincount(x, minlength="foobar"))

assert_raises_regex(ValueError, "minlength must be positive",

lambda: np.bincount(x, minlength=-1))

assert_raises_regex(ValueError, "minlength must be positive",

lambda: np.bincount(x, minlength=0))

Example 5

def test_allclose(self):

# Tests allclose on arrays

a = np.random.rand(10)

b = a + np.random.rand(10) * 1e-8

self.assertTrue(allclose(a, b))

# Test allclose w/ infs

a[0] = np.inf

self.assertTrue(not allclose(a, b))

b[0] = np.inf

self.assertTrue(allclose(a, b))

# Test allclose w/ masked

a = masked_array(a)

a[-1] = masked

self.assertTrue(allclose(a, b, masked_equal=True))

self.assertTrue(not allclose(a, b, masked_equal=False))

# Test comparison w/ scalar

a *= 1e-8

a[0] = 0

self.assertTrue(allclose(a, 0, masked_equal=True))

# Test that the function works for MIN_INT integer typed arrays

a = masked_array([np.iinfo(np.int_).min], dtype=np.int_)

self.assertTrue(allclose(a, a))

Example 6

def _parse_fields(point):

output = []

for k, v in point['fields'].items():

k = escape(k, key_escape)

# noinspection PyUnresolvedReferences

if isinstance(v, bool):

output.append('{k}={v}'.format(k=k, v=str(v).upper()))

elif isinstance(v, (int, np.integer)):

output.append('{k}={v}i'.format(k=k, v=v))

elif isinstance(v, str):

output.append('{k}="{v}"'.format(k=k, v=v.translate(str_escape)))

elif v is None or np.isnan(v):

continue

else:

# Floats and other numerical formats go here.

# TODO: Add unit test

output.append('{k}={v}'.format(k=k, v=v))

return ','.join(output)

Example 7

def get_subvolume(self, bounds):

if bounds.start is None or bounds.stop is None:

image_subvol = self.image_data

label_subvol = self.label_data

else:

image_subvol = self.image_data[

bounds.start[0]:bounds.stop[0],

bounds.start[1]:bounds.stop[1],

bounds.start[2]:bounds.stop[2]]

label_subvol = None

if np.issubdtype(image_subvol.dtype, np.integer):

raise ValueError('Sparse volume access does not support image data coercion.')

seed = bounds.seed

if seed is None:

seed = np.array(image_subvol.shape, dtype=np.int64) // 2

return Subvolume(image_subvol, label_subvol, seed, bounds.label_id)

Example 8

def __init__(self, X_train, y_train, X_test, y_test, categorical=True):

self._x_train = X_train

self._x_test = X_test

# are the targets to be made one hot vectors

if categorical:

self._y_train = np_utils.to_categorical(y_train)

self._y_test = np_utils.to_categorical(y_test)

self._output_size = self._y_train.shape[1]

# handle sparse output classification

elif issubclass(y_train.dtype.type, np.integer):

self._y_train = y_train

self._y_test = y_test

self._output_size = self._y_train.max() + 1 # assume 0 based indexes

# not classification, just copy them

else:

self._y_train = y_train

self._y_test = y_test

self._output_size = self._y_train.shape[1]

Example 9

def __init__(self, X_train, y_train, X_test, y_test, categorical=True):

self._x_train = X_train

self._x_test = X_test

# are the targets to be made one hot vectors

if categorical:

self._y_train = np_utils.to_categorical(y_train)

self._y_test = np_utils.to_categorical(y_test)

self._output_size = self._y_train.shape[1]

# handle sparse output classification

elif issubclass(y_train.dtype.type, np.integer):

self._y_train = y_train

self._y_test = y_test

self._output_size = self._y_train.max() + 1 # assume 0 based indexes

# not classification, just copy them

else:

self._y_train = y_train

self._y_test = y_test

self._output_size = self._y_train.shape[1]

Example 10

def __init__(self, X_train, y_train, X_test, y_test, categorical=True):

self._x_train = X_train

self._x_test = X_test

# are the targets to be made one hot vectors

if categorical:

self._y_train = np_utils.to_categorical(y_train)

self._y_test = np_utils.to