def to_abstract_test(self, x: (bool, int, float, str,
np.floating, np.integer,
type(None), EnvInstance)):
return AbstractScalar({
VALUE: x,
TYPE: dtype.pytype_to_myiatype(type(x)),
})
def to_abstract_test(self, x: (bool, int, float, str, np.floating, np.integer,
type(None), type(NotImplemented), EnvInstance)):
return AbstractScalar({
VALUE:
x,
TYPE:
xtype.pytype_to_myiatype(x if inspect.isclass(x) else type(x)),
})
def to_abstract_test(self, x: np.ndarray):
return AbstractArray(
AbstractScalar({
VALUE: ANYTHING,
TYPE: dtype.np_dtype_to_type(str(x.dtype)),
}),
{SHAPE: x.shape}
)
def arr_of(t, shp, value):
return AbstractArray(AbstractScalar({
VALUE: value,
TYPE: t,
}), {
SHAPE: shp,
TYPE: xtype.NDArray
})
def to_abstract_test(
self,
x: (
xtype.Number,
xtype.String,
xtype.Bool,
xtype.EnvType,
xtype.UniverseType,
),
):
return AbstractScalar({VALUE: ANYTHING, TYPE: x})
def arr_of(t, shp, value):
"""Generate symbolic array."""
return AbstractArray(
AbstractScalar({
VALUE: value,
TYPE: t
}),
{
SHAPE: shp,
TYPE: xtype.NDArray
},
)
def to_relay_type(self, a: AbstractScalar):
"""Convert a myia abstract to a Relay type."""
tp = a.xtype()
if issubclass(tp, Bool):
return relay.ty.scalar_type("bool")
elif issubclass(tp, Nil):
return relay.ty.TupleType([])
elif issubclass(tp, EnvType):
return env_type()
elif issubclass(tp, UniverseType):
return relay.ty.TupleType([])
else:
return relay.ty.scalar_type(type_to_np_dtype(tp))
def test_annotation_merge():
with pytest.raises(MyiaTypeError):
annotation_merge(
AbstractUnion(
[AbstractScalar({TYPE: i16}),
AbstractScalar({TYPE: f32})]),
AbstractScalar({TYPE: i32}),
)
scalar = AbstractScalar({TYPE: f32})
union = AbstractUnion([AbstractScalar({TYPE: i16}), scalar])
assert annotation_merge(union, scalar) is scalar
assert annotation_merge(union, scalar, forced=True) is union
generic_list_type = type_to_abstract(list)
specific_list_type = to_abstract([1, 2])
assert isinstance(generic_list_type, AbstractUnion)
assert (annotation_merge(generic_list_type,
specific_list_type,
forced=True) is generic_list_type)
assert isinstance(annotation_merge(generic_list_type, specific_list_type),
AbstractADT)
def to_abstract_test(
self,
x: (
bool,
int,
float,
str,
np.floating,
np.integer,
type(None),
type(NotImplemented),
EnvInstance,
),
):
"""Convert a python value to a myia abstract object"""
return AbstractScalar({
VALUE:
x,
TYPE:
xtype.pytype_to_myiatype(x if inspect.isclass(x) else type(x)),
})
def to_abstract_test(self, x: (dtype.Number, dtype.String,
dtype.Bool, dtype.EnvType)):
return AbstractScalar({VALUE: ANYTHING, TYPE: x})
from dataclasses import dataclass
from myia.abstract import (
ANYTHING as ANY,
TYPE,
VALUE,
AbstractList,
AbstractScalar,
from_value,
)
from myia.dtype import Bool, Float, Int
B = AbstractScalar({VALUE: ANY, TYPE: Bool})
i16 = AbstractScalar({VALUE: ANY, TYPE: Int[16]})
i32 = AbstractScalar({VALUE: ANY, TYPE: Int[32]})
i64 = AbstractScalar({VALUE: ANY, TYPE: Int[64]})
f16 = AbstractScalar({VALUE: ANY, TYPE: Float[16]})
f32 = AbstractScalar({VALUE: ANY, TYPE: Float[32]})
f64 = AbstractScalar({VALUE: ANY, TYPE: Float[64]})
li16 = AbstractList(i16)
li32 = AbstractList(i32)
li64 = AbstractList(i64)
lf16 = AbstractList(f16)
lf32 = AbstractList(f32)
lf64 = AbstractList(f64)
def test_numpy_scalar_to_abstract():
s1 = AbstractScalar({VALUE: 2, TYPE: i16})
assert to_abstract_test(np.int16(2)) == s1
s2 = AbstractScalar({VALUE: 1.5, TYPE: f32})
assert to_abstract_test(np.float32(1.5)) == s2
def test_to_abstract_skey():
inst = SymbolicKeyInstance(Constant(123), 456)
expected = AbstractScalar({VALUE: inst, TYPE: ty.SymbolicKeyType})
assert to_abstract(inst) == expected
def upcast(self, x: AbstractScalar, nbits):
return AbstractScalar({VALUE: x.xvalue(), TYPE: ty.Int[nbits]})
async def upcast_async(self, x: AbstractScalar):
return AbstractScalar({
VALUE: x.values[VALUE],
TYPE: ty.Int[64],
})
def S(x=ANYTHING, t=None):
"""Generate a symbolic scalar."""
return AbstractScalar({
VALUE: x,
TYPE: t or xtype.pytype_to_myiatype(type(x))
})
def S(x=ANYTHING, t=None):
return AbstractScalar({
VALUE: x,
TYPE: t or dtype.pytype_to_myiatype(type(x)),
})
def upcast(self, x: AbstractScalar, nbits):
return AbstractScalar({
VALUE: x.values[VALUE],
TYPE: ty.Int[nbits],
})
