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_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_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()
