def random_velkrelu_special_mv(height, width, vlen, dim_flag): special_fp16_less_eq_zero = np.array([ 0, 0.0, np.half('inf'), np.half('-inf'), np.half('nan'), 0.1, 10, 65500, 6.104e-5 ], dtype=np.float16) rs1 = special_fp16_less_eq_zero cnt = special_fp16_less_eq_zero.size for x in range(cnt - 1): tmp = np.roll(special_fp16_less_eq_zero, 1) rs1 = np.append(rs1, tmp) special_fp16_less_eq_zero = tmp rs1 = np.reshape(rs1, (cnt, cnt)) rs2 = np.array( [0.1, 0.1, np.half('nan'), 0.1, 10, 65500, 6.104e-5, 6e-8, -1.0], dtype=np.float16) if 1 == dim_flag: rs1 = rs1.swapaxes(1, 0) return pytest.param(rs1, rs2, dim_flag, id=f'{height}x{width}x{vlen}x{dim_flag}')
def test_against_known_values(self): R = fractions.Fraction assert_equal(R(1075, 512), R(*np.half(2.1).as_integer_ratio())) assert_equal(R(-1075, 512), R(*np.half(-2.1).as_integer_ratio())) assert_equal(R(4404019, 2097152), R(*np.single(2.1).as_integer_ratio())) assert_equal(R(-4404019, 2097152), R(*np.single(-2.1).as_integer_ratio())) assert_equal(R(4728779608739021, 2251799813685248), R(*np.double(2.1).as_integer_ratio())) assert_equal(R(-4728779608739021, 2251799813685248), R(*np.double(-2.1).as_integer_ratio()))
def test_floating_overflow(self): """ Strings containing an unrepresentable float overflow """ fhalf = np.half('1e10000') assert_equal(fhalf, np.inf) fsingle = np.single('1e10000') assert_equal(fsingle, np.inf) fdouble = np.double('1e10000') assert_equal(fdouble, np.inf) flongdouble = assert_warns(RuntimeWarning, np.longdouble, '1e10000') assert_equal(flongdouble, np.inf) fhalf = np.half('-1e10000') assert_equal(fhalf, -np.inf) fsingle = np.single('-1e10000') assert_equal(fsingle, -np.inf) fdouble = np.double('-1e10000') assert_equal(fdouble, -np.inf) flongdouble = assert_warns(RuntimeWarning, np.longdouble, '-1e10000') assert_equal(flongdouble, -np.inf)
def test_to_json(self): assert JsonUtils.encoder().as_str("hi") == '"hi"\n' assert JsonUtils.encoder().as_str(["hi", "bye" ]) == '[\n "hi",\n "bye"\n]\n' data = { "list": [{ "numbers": { 1: np.asarray([float("inf"), 0]), 2: np.asarray([1, 1]), 3: np.half(float("inf")), 4: np.half(float("-inf")), 5: float("inf"), 6: float("-inf"), 7: 1, } }] } x = JsonUtils.encoder().as_str(data) assert (x == inspect.cleandoc(""" { "list": [ { "numbers": { "1": [ "inf", "0.0" ], "2": [ "1", "1" ], "3": "inf", "4": "-inf", "5": "inf", "6": "-inf", "7": 1 } } ] } """) + "\n")
def meconv_mm_special_fp(h, w, cin, cout, kh, kw, padding, sk, dl): vs1 = np.array([ 0.0, -0.0, np.half('inf'), np.half('-inf'), np.half('nan'), 0.1, 10, 65500, 6.104e-05, 6.e-08 ], dtype=np.float16).reshape((1, 1, 10, 1)) vs2 = np.array([ 0.0, -0.0, np.half('inf'), np.half('-inf'), np.half('nan'), 0.1, 10, 65500, 6.104e-05, 6.e-08 ], dtype=np.float16).reshape((1, 1, 1, 10)) return pytest.param( vs1, vs2, h, w, cin, cout, kh, kw, padding, sk, dl, id=f'{h}x{w}x{cin}x{cout}x{kh}x{kw}x{padding}x{sk}x{dl}')
def softfloat_memul_ts_mm(l): [lb, ub, m, k, n] = l vs1 = np.array( [np.half('inf'), np.half('-inf'), 0, np.half('nan')], dtype=np.float16).reshape(k, m) vs2 = np.array( [np.half('inf'), np.half('-inf'), 0, np.half('nan')], dtype=np.float16).reshape(k, n) return [vs1, vs2]
def __init__(self): NT = namedtuple('NT', tuple('abc')) self.values = [ np.longlong(-1), np.int_(-1), np.intc(-1), np.short(-1), np.byte(-1), np.ubyte(1), np.ushort(1), np.uintc(1), np.uint(1), np.ulonglong(1), np.half(1.0), np.single(1.0), np.float_(1.0), np.longfloat(1.0), np.csingle(1.0j), np.complex_(1.0j), np.clongfloat(1.0j), np.bool_(0), np.str_('1'), np.unicode_('1'), np.void(1), np.object(), np.datetime64('NaT'), np.timedelta64('NaT'), np.nan, 12, 12.0, True, None, float('NaN'), object(), (1, 2, 3), NT(1, 2, 3), datetime.date(2020, 12, 31), datetime.timedelta(14), ] # Datetime & Timedelta for precision in ['ns', 'us', 'ms', 's', 'm', 'h', 'D', 'M', 'Y']: for kind, ctor in (('m', np.timedelta64), ('M', np.datetime64)): self.values.append(ctor(12, precision)) for size in (1, 8, 16, 32, 64, 128, 256, 512): self.values.append(bytes(size)) self.values.append('x' * size)
class TestNumpyJSONEncoder(unittest.TestCase): @parameterized.expand( [(numpy.bool_(1), True), (numpy.bool8(1), True), (numpy.byte(1), 1), (numpy.int8(1), 1), (numpy.ubyte(1), 1), (numpy.uint8(1), 1), (numpy.short(1), 1), (numpy.int16(1), 1), (numpy.ushort(1), 1), (numpy.uint16(1), 1), (numpy.intc(1), 1), (numpy.int32(1), 1), (numpy.uintc(1), 1), (numpy.uint32(1), 1), (numpy.int_(1), 1), (numpy.int32(1), 1), (numpy.uint(1), 1), (numpy.uint32(1), 1), (numpy.longlong(1), 1), (numpy.int64(1), 1), (numpy.ulonglong(1), 1), (numpy.uint64(1), 1), (numpy.half(1.0), 1.0), (numpy.float16(1.0), 1.0), (numpy.single(1.0), 1.0), (numpy.float32(1.0), 1.0), (numpy.double(1.0), 1.0), (numpy.float64(1.0), 1.0), (numpy.longdouble(1.0), 1.0)] + ([ (numpy.float128(1.0), 1.0) # unavailable on windows ] if hasattr(numpy, 'float128') else [])) def test_numpy_primary_type_encode(self, np_val, py_val): self.assertEqual(json.dumps(py_val), json.dumps(np_val, cls=NumpyEncoder)) @parameterized.expand([ (numpy.array([1, 2, 3], dtype=numpy.int), [1, 2, 3]), (numpy.array([[1], [2], [3]], dtype=numpy.double), [[1.0], [2.0], [3.0]]), (numpy.zeros((2, 2), dtype=numpy.bool_), [[False, False], [False, False]]), (numpy.array([('Rex', 9, 81.0), ('Fido', 3, 27.0)], dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')]), [['Rex', 9, 81.0], ['Fido', 3, 27.0]]), (numpy.rec.array([(1, 2., 'Hello'), (2, 3., "World")], dtype=[('foo', 'i4'), ('bar', 'f4'), ('baz', 'U10')]), [[1, 2.0, "Hello"], [2, 3.0, "World"]]) ]) def test_numpy_array_encode(self, np_val, py_val): self.assertEqual(json.dumps(py_val), json.dumps(np_val, cls=NumpyEncoder))
def find_vol_(target_value, S, K, T, r, *args): MAX_ITERATIONS = 200 PRECISION = 1.0e-5 sigma = np.full((unusual_pred['bs_price'].shape[0]), np.half(0.5)) for se, s in enumerate(sigma): for i in range(0, MAX_ITERATIONS): price = bs_call(S.iloc[se], K.iloc[se], T.iloc[se], r, sigma[se]) # price = bs_call(S, K, T, r, sigma) vega = bs_vega(S.iloc[se], K.iloc[se], T.iloc[se], r, sigma[se]) # vega = bs_vega(S, K, T, r, sigma) # diff = target_value.iloc[se] - price.iloc[se] # our root diff = target_value[se] - price if abs(diff) < PRECISION: break sigma[se] = sigma[se] + diff/vega.iloc[se] print(sigma[se]) # if (abs(diff) < PRECISION): # return sigma # = sigma + diff/vega # f(x) / f'(x) print(price) print(vega) print(diff) return sigma # value wasn't found, return best guess so far
optimizer.zero_grad() loss = criterion(prediction, y_train) #MSELoss loss.backward() optimizer.step() running_loss_MSE.append(loss.item()) running_loss_MAE.append(F.l1_loss(prediction, y_train).item()) running_loss_R2_score.append(R2_score(prediction.data.numpy(), y_train.data.numpy())) if t % 99 == 0: plt.cla() plt.scatter(x_train.data.numpy(),y_train.data.numpy()) #绘制真实曲线 plt.plot(x_train.data.numpy(),prediction.data.numpy(),'+r',lw=5) plt.text(-0.2,-1,'Loss='+str(np.half(loss.item())),fontdict={'size':15,'color':'red'}) plt.pause(0.1) plt.ioff() plt.show() print('------ prediction and visualization ------') y_prediction = net(x_test) loss_prediction = criterion(y_prediction, y_test) loss_prediction = loss_prediction.item() plt.plot(x_test.data.numpy(),y_test.data.numpy(),'+b') plt.plot(x_test.data.numpy(),y_prediction.data.numpy(),'or') plt.show()
if contador == 0: i[contador + 1] = -1 elif contador == n - 1: i[contador - 1] = -1 else: i[contador - 1] = -1 i[contador + 1] = -1 contador += 1 A = half(A) memoria = 2 * n * n * 2 #Half t1 = perf_counter() Ainv = linalg.inv(matrix(A), overwrite_a=False) t2 = perf_counter() dt = t2 - t1 archivo.write(f'{n} {dt} {memoria}\n') archivo.close()
reveal_type(np.short()) # E: {short} reveal_type(np.intc()) # E: {intc} reveal_type(np.intp()) # E: {intp} reveal_type(np.int0()) # E: {intp} reveal_type(np.int_()) # E: {int_} reveal_type(np.longlong()) # E: {longlong} reveal_type(np.ubyte()) # E: {ubyte} reveal_type(np.ushort()) # E: {ushort} reveal_type(np.uintc()) # E: {uintc} reveal_type(np.uintp()) # E: {uintp} reveal_type(np.uint0()) # E: {uintp} reveal_type(np.uint()) # E: {uint} reveal_type(np.ulonglong()) # E: {ulonglong} reveal_type(np.half()) # E: {half} reveal_type(np.single()) # E: {single} reveal_type(np.double()) # E: {double} reveal_type(np.float_()) # E: {double} reveal_type(np.longdouble()) # E: {longdouble} reveal_type(np.longfloat()) # E: {longdouble} reveal_type(np.csingle()) # E: {csingle} reveal_type(np.singlecomplex()) # E: {csingle} reveal_type(np.cdouble()) # E: {cdouble} reveal_type(np.complex_()) # E: {cdouble} reveal_type(np.cfloat()) # E: {cdouble} reveal_type(np.clongdouble()) # E: {clongdouble} reveal_type(np.clongfloat()) # E: {clongdouble} reveal_type(np.longcomplex()) # E: {clongdouble}
# importar libreria de soporte para vectores y matrices import numpy as np # Tipos de datos primitivos (se convierte el valor al tipo especificado) np.bool(valor) # booleano almacenado como un byte (verdadero o falso) np.byte(valor) # entero con signo almacenado como un byte (definido por la plataforma) np.ubyte(valor) # entero sin signo almacenado como un byte (definido por la plataforma) np.short(valor) # entero corto con signo (definido por la plataforma) np.ushort(valor) # entero corto sin signo (definido por la plataforma) np.intc(valor) # entero medio con signo (definido por la plataforma) np.uintc(valor) # entero medio sin signo (definido por la plataforma) np.int_(valor) # entero largo con signo (definido por la plataforma) np.uint(valor) # entero largo sin signo (definido por la plataforma) np.longlong(valor) # entero largo largo con signo (definido por la plataforma) np.ulonglong(valor) # entero largo largo sin signo (definido por la plataforma) np.half(valor) # Flotante de precisión media (signo de 1 bit, exponente de 5 bits, mantisa de 10 bits) np.float16(valor) # Flotante de precisión media (signo de 1 bit, exponente de 5 bits, mantisa de 10 bits) np.single(valor) # Flotante de precisión simple (signo de 1 bit, exponente de 8 bits, mantisa de 23 bits) np.double(valor) # Flotante de precisión doble (signo de 1 bit, exponente de 11 bits, mantisa de 52 bits) np.longdouble(valor) # Flotante de precisión extendida (definido por la plataforma) np.csingle(valor) # Número complejo representado por dos flotantes de precisión simple (componente real e imaginario) np.cdouble(valor) # Número complejo representado por dos flotantes de precisión doble (componente real e imaginario) np.clongdouble(valor) # Número complejo representado por dos flotantes de precisión extendida (componente real e imaginario) # Tipos de datos con Alias de tamaño (se convierte el valor al tipo especificado) np.int8(valor) # entero de 1 byte con signo (-128 a 127) np.uint8(valor) # entero de 1 byte sin signo (0 a 255) np.int16(valor) # entero de 2 bytes con signo (-32768 a 32767) np.uint16(valor) # entero de 2 bytes sin signo (0 a 65535) np.int32(valor) # entero de 4 bytes con signo (-2147483648 a 2147483647) np.uint32(valor) # entero de 4 bytes sin signo (0 a 4294967295)
def golden( self ): if 'vs1' in self.keys(): if np.isinf( self['vs1'][0][0] ) or np.isnan( self['vs1'][0][0] ): vd = np.array([ [np.half('inf'), np.half('-inf'), np.half('nan'), np.half('nan')], [np.half('-inf'), np.half('inf'), np.half('nan'), np.half('nan')], [np.half('nan'), np.half('nan'), np.half(0), np.half('nan')], [np.half('nan'), np.half('nan'), np.half('nan'), np.half('nan')]], dtype=np.float16) return vd else: return np.matmul( self['vs1'], self['vs2'], dtype=np.float16 )
'int_4': -127649217, 'int_5': 212121212, 'int_6': np.byte(1234), 'int_7': np.short(1234), 'int_8': np.intc(1234), 'int_9': np.longlong(1234), 'int_10': np.int8(1234), 'int_11': np.int16(1234), 'int_12': np.int32(1234), 'int_13': np.int64(1234), 'float_1': 0.0, 'float_2': 1.0, 'float_3': 1e-15, 'float_4': 1.26738e14, 'float_5': 1.23, 'float_6': np.half(1234.0), 'float_7': np.single(1234.0), 'float_8': np.double(1234.0), 'float_9': np.longdouble(1234.0), 'float_10': np.float32(1234.0), 'float_11': np.float64(1234.0), # Needs typeshed sync 'complex_1': complex(0.0j), # type: ignore # Needs typeshed sync 'complex_2': complex(0.0 + 0.0j), # type: ignore 'complex_3': 1.0j, 'complex_4': 1.0 + 1.0j, 'complex_5': 1.0 - 1.0j, 'complex_7': np.csingle(1234 + 1234j), 'complex_8': np.cdouble(1234 + 1234j), 'complex_9': np.clongdouble(1234 + 1234j),
loss = criterion(prediction, y_train) #MSELoss loss.backward() optimizer.step() running_loss_MSE.append(loss.item()) running_loss_MAE.append(F.l1_loss(prediction, y_train).item()) running_loss_R2_score.append( R2_score(prediction.data.numpy(), y_train.data.numpy())) if t % 99 == 0: plt.cla() plt.scatter(x_train.data.numpy(), y_train.data.numpy()) #绘制真实曲线 plt.plot(x_train.data.numpy(), prediction.data.numpy(), '+r', lw=5) plt.text(-0.2, -1, 'Loss=' + str(np.half(loss.item())), fontdict={ 'size': 15, 'color': 'red' }) plt.pause(0.1) plt.ioff() plt.show() print('------ prediction and visualization ------') y_prediction = net(x_test) loss_prediction = criterion(y_prediction, y_test) loss_prediction = loss_prediction.item()
def test_translation(self): self.assertEqual(translate_dtype(np.bool(True)), "boolean") self.assertEqual(translate_dtype(np.int(5)), "integer") self.assertEqual(translate_dtype(np.float(5.21)), "float") self.assertEqual(translate_dtype(np.half(5.21)), "float")
reveal_type(np.short()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.intc()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.intp()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.int0()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.int_()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.longlong()) # E: numpy.signedinteger[numpy.typing._ reveal_type(np.ubyte()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.ushort()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.uintc()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.uintp()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.uint0()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.uint()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.ulonglong()) # E: numpy.unsignedinteger[numpy.typing._ reveal_type(np.half()) # E: numpy.floating[numpy.typing._ reveal_type(np.single()) # E: numpy.floating[numpy.typing._ reveal_type(np.double()) # E: numpy.floating[numpy.typing._ reveal_type(np.float_()) # E: numpy.floating[numpy.typing._ reveal_type(np.longdouble()) # E: numpy.floating[numpy.typing._ reveal_type(np.longfloat()) # E: numpy.floating[numpy.typing._ reveal_type(np.csingle()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.singlecomplex()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.cdouble()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.complex_()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.cfloat()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.clongdouble()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.clongfloat()) # E: numpy.complexfloating[numpy.typing._ reveal_type(np.longcomplex()) # E: numpy.complexfloating[numpy.typing._
def test_table_typing_numpy(): # Pulled from https://numpy.org/devdocs/user/basics.types.html # Numerics table = wandb.Table(columns=["A"], dtype=[NumberType]) table.add_data(None) table.add_data(42) table.add_data(np.byte(1)) table.add_data(np.short(42)) table.add_data(np.ushort(42)) table.add_data(np.intc(42)) table.add_data(np.uintc(42)) table.add_data(np.int_(42)) table.add_data(np.uint(42)) table.add_data(np.longlong(42)) table.add_data(np.ulonglong(42)) table.add_data(np.half(42)) table.add_data(np.float16(42)) table.add_data(np.single(42)) table.add_data(np.double(42)) table.add_data(np.longdouble(42)) table.add_data(np.csingle(42)) table.add_data(np.cdouble(42)) table.add_data(np.clongdouble(42)) table.add_data(np.int8(42)) table.add_data(np.int16(42)) table.add_data(np.int32(42)) table.add_data(np.int64(42)) table.add_data(np.uint8(42)) table.add_data(np.uint16(42)) table.add_data(np.uint32(42)) table.add_data(np.uint64(42)) table.add_data(np.intp(42)) table.add_data(np.uintp(42)) table.add_data(np.float32(42)) table.add_data(np.float64(42)) table.add_data(np.float_(42)) table.add_data(np.complex64(42)) table.add_data(np.complex128(42)) table.add_data(np.complex_(42)) # Booleans table = wandb.Table(columns=["A"], dtype=[BooleanType]) table.add_data(None) table.add_data(True) table.add_data(False) table.add_data(np.bool_(True)) # Array of Numerics table = wandb.Table(columns=["A"], dtype=[[NumberType]]) table.add_data(None) table.add_data([42]) table.add_data(np.array([1, 0], dtype=np.byte)) table.add_data(np.array([42, 42], dtype=np.short)) table.add_data(np.array([42, 42], dtype=np.ushort)) table.add_data(np.array([42, 42], dtype=np.intc)) table.add_data(np.array([42, 42], dtype=np.uintc)) table.add_data(np.array([42, 42], dtype=np.int_)) table.add_data(np.array([42, 42], dtype=np.uint)) table.add_data(np.array([42, 42], dtype=np.longlong)) table.add_data(np.array([42, 42], dtype=np.ulonglong)) table.add_data(np.array([42, 42], dtype=np.half)) table.add_data(np.array([42, 42], dtype=np.float16)) table.add_data(np.array([42, 42], dtype=np.single)) table.add_data(np.array([42, 42], dtype=np.double)) table.add_data(np.array([42, 42], dtype=np.longdouble)) table.add_data(np.array([42, 42], dtype=np.csingle)) table.add_data(np.array([42, 42], dtype=np.cdouble)) table.add_data(np.array([42, 42], dtype=np.clongdouble)) table.add_data(np.array([42, 42], dtype=np.int8)) table.add_data(np.array([42, 42], dtype=np.int16)) table.add_data(np.array([42, 42], dtype=np.int32)) table.add_data(np.array([42, 42], dtype=np.int64)) table.add_data(np.array([42, 42], dtype=np.uint8)) table.add_data(np.array([42, 42], dtype=np.uint16)) table.add_data(np.array([42, 42], dtype=np.uint32)) table.add_data(np.array([42, 42], dtype=np.uint64)) table.add_data(np.array([42, 42], dtype=np.intp)) table.add_data(np.array([42, 42], dtype=np.uintp)) table.add_data(np.array([42, 42], dtype=np.float32)) table.add_data(np.array([42, 42], dtype=np.float64)) table.add_data(np.array([42, 42], dtype=np.float_)) table.add_data(np.array([42, 42], dtype=np.complex64)) table.add_data(np.array([42, 42], dtype=np.complex128)) table.add_data(np.array([42, 42], dtype=np.complex_)) # Array of Booleans table = wandb.Table(columns=["A"], dtype=[[BooleanType]]) table.add_data(None) table.add_data([True]) table.add_data([False]) table.add_data(np.array([True, False], dtype=np.bool_)) # Nested arrays table = wandb.Table(columns=["A"]) table.add_data([[[[1, 2, 3]]]]) table.add_data(np.array([[[[1, 2, 3]]]]))
from scipy import matrix, rand, linalg import scipy import numpy from time import perf_counter casos = [ 2, 5, 10, 12, 15, 20, 30, 40, 45, 50, 55, 60, 75, 100, 125, 160, 200, 250, 350, 500, 600, 800, 1000, 2000, 5000, 10000 ] for casoN in range(11)[1:]: dtype = "half" bits = 16 archivo = open(f'timing_inv_caso_3_{dtype}_{casoN}.txt', 'w') for N in casos: A = numpy.half(numpy.random.rand(N, N)) t1 = perf_counter() C = linalg.inv(A, overwrite_a=True) t2 = perf_counter() dt = t2 - t1 size = 1 * ( N**2 ) * bits / 8 #2 matrices (A,A.I), N**2, 8 Bytes por float -> 8 bits = 1 byte #1 KB 10e3 Bytes #1 MB 10e6 Bytes #1 GB 10e9 Bytes string = f'{N} {dt} {size}\n'
for i in range(Ncorridas): fid = open(f"caso_3_half{i}.txt", "w") # cambiar dts = [] mem = [] for N in Ns: A = zeros((N,N)) fill_diagonal(A, 2) for i in range(N): for j in range(N): if i+1 == j or i-1 == j: A[i][j] = -1 A = half(A) # Este va variando t1 = perf_counter() Ainv = linalg.inv(matrix(A), overwrite_a=True) #Ojo con este t2 = perf_counter() dt = t2 - t1 size = (N**2) * 2 # Half (2 Bytes - 16 bits), varía también dts.append(dt) mem.append(size) fid.write(f"{N} {dt} {size} \n") print (Ainv) print(f"Tiempo transcurrido = {dt} s")
np.short() np.intc() np.intp() np.int0() np.int_() np.longlong() np.ubyte() np.ushort() np.uintc() np.uintp() np.uint0() np.uint() np.ulonglong() np.half() np.single() np.double() np.float_() np.longdouble() np.longfloat() np.csingle() np.singlecomplex() np.cdouble() np.complex_() np.cfloat() np.clongdouble() np.clongfloat() np.longcomplex()