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], })