async def __arepr__(self) -> str: async with finish() as f: baseobj = f.future(self.unseeded_base_object.__arepr__()) hasname = f.future(self._ahasname) name = f.future(self._aname) args = ', {}'.format(await self.get_asyncattr(args)) if self.args is not Undefined else '' return '{}({}{}{})'.format(self.__class__.__name__, await baseobj, args, await name if await hasname else '')
async def deriv_w_args(self, du: Variable, b: ValuedObj, p: ValuedObj) -> (ValuedObj, Undefined): async with finish() as f: bc = f.future(b._aisconst(du)) pc = f.future(p._aisconst(du)) bc = await bc pc = await pc if not bc: bd = f.future(b._aderiv(du)) if not pc: pd = f.future(p._aderiv(du)) from pymath2.extensions.functions import ln lnb = await ln.__acall__(b) if bc and pc: return await self.scrub(0) elif not bc and pc: pm1 = p.__asub__(1) bpm1 = b.__apow__(await pm1) return await (await p.__amul__(await bpm1)).__amul__(await bd) # return p * b ** (p - 1) * await bd elif bc and not pc: assert 0, 'todo' return b**p * lnb * await pd else: assert not bc and not pc, str(bc) + str(pc) assert 0, 'todo' logger.critical('NO!') raise Exception() quit() # return b ** p * (await bd * p / b + await pd * lnb) assert False #Every case should have been taken care of
async def _bool_oper_str(self, l, r) -> str: # print('Dummy Method: _bool_oper_str') #still is kinda async with finish() as f: l = f.future(self._possibly_surround_in_parens(l)) r = f.future(self._possibly_surround_in_parens(r)) n = f.future(self._aname) return '{} {} {}'.format(l.result(), n.result(), r.result())
async def deriv_w_args(self, du: Variable, l: ValuedObj, r: ValuedObj) -> (ValuedObj, Undefined): async with finish() as f: ld = f.future(l._aderiv(du)) rd = f.future(r._aderiv(du)) lpart = f.future((await ld).__amul__(r)) rpart = f.future((l).__amul__(await rd)) return await (await lpart).__aadd__(await rpart)
async def _args_str(self): warnloop(logger) assert inloop() ret = [] async with finish() as f: for x in (f.future(arg) for arg in self.args): ret.append(arg) return str([x.result() for x in ret])
async def list_str(inp, repr=False): ret = [] async with finish() as f: for x in inp: ret.append( f.future( MathObj.get_asyncattr( x, '__repr__' if repr else '__str__'))) return [x.result() for x in ret]
async def deriv_w_args(self, du: Variable, n: ValuedObj, d: ValuedObj) -> (ValuedObj, Undefined): async with finish() as f: nd = f.future(n._aderiv(du)) dd = f.future(d._aderiv(du)) dnd = f.future(d.__amul__(await nd)) ndd = f.future(n.__amul__(await dd)) dd2 = f.future(d.__apow__(2)) up = f.future((await dnd).__asub__(await ndd)) return await up.__adiv__(dd2)
async def __ainit__(self, _normal_operator: Operator, **kwargs) -> None: assert 'name' not in kwargs assert 'priority' not in kwargs assert 'req_arg_len' not in kwargs async with finish() as f: f.future(self.__asetattr__('_normal_operator', _normal_operator)) f.future(super().__ainit__( name=await _normal_operator._aname, priority=_normal_operator.priority, req_arg_len=_normal_operator.req_arg_len, **kwargs))
async def __arepr__(self) -> str: async with finish() as f: name = f.future(self._aname) value = f.future(self._avalue) hasvalue = f.future(self._ahasvalue) prname = f.future(self.get_asyncattr(await name)) prvalue = 'value=' + await self.get_asyncattr( await value) if await hasvalue else Undefined return '{}({})'.format( self.__class__.__name__, ', '.join(x for x in ('myname', prvalue) if x is not Undefined))
async def __ainit__(self, unseeded_base_object: 'UnseededFunction', args: tuple = Undefined, **kwargs) -> None: warnloop(logger) assert inloop() if __debug__: from .unseeded_function import UnseededFunction assert isinstance(unseeded_base_object, UnseededFunction), '{}, type {}'.format(unseeded_base_object, type(unseeded_base_object)) async with finish() as f: f.future(super().__ainit__(**kwargs)) f.future(self.__asetattr__('unseeded_base_object', unseeded_base_object)) f.future(self.__asetattr__('args', args)) assert hasattr(self, 'unseeded_base_object') assert hasattr(self, 'args')
async def deriv_w_args(self, du: Variable, *args: [ValuedObj]) -> (ValuedObj, Undefined): assert len(args) == 1 async with finish() as f: name = f.future(self._aname) deriv = f.future(args[0]._aderiv(du)) name = await name if name == '-': return - await deriv if name == '+': return + await deriv return await super().deriv_w_args(self, du, *args)
async def __astr__(self) -> str: if await self._ahasvalue: return await (await self._avalue).__astr__() async with finish() as f: name = f.future(self._aname) primestr = f.future(self.unseeded_base_object._aprime_str(self.unseeded_base_object.deriv_num)) if self.args is Undefined: args = f.future(self.args.__astr__()) else: args = [] for arg in (f.future(x.__astr__()) for x in self.args): args.append(await arg) args = ', '.join(args) return '{}{}({})'.format(await name, await primestr, args)
async def dict_str(inp): ret = {} async with finish() as f: for key, val in inp.items(): assert not isinstance( key, (dict, list)) # havent written code to handle if isinstance(val, dict): val = MathObj.dict_str(val) if isinstance(val, (list, tuple)): val = MathObj.list_str(val) else: val = MathObj.get_asyncattr( val, '__repr__' if repr else '__str__') ret[await MathObj.get_asyncattr( key, '__repr__' if repr else '__str__')] = f.future(val) return {k: v.result() for k, v in ret.items()}
async def __atruediv__(self, other): assert inloop() async with finish() as f: sv = f.future(self._avalue) ov = f.future(other._avalue) return await Derivative._a_get_deriv(sv.result(), ov.result())
async def wrap_func(l, r): async with finish() as f: lv = f.future(l.value) rv = f.future(r.value) return await _domethod('__gt__', lv.result(), rv.result())
async def __ainit__(self, priority: int, **kwargs) -> None: assert priority is not Undefined async with finish() as f: f.future(super().__ainit__(**kwargs)) f.future(self.__asetattr__('priority', priority))
async def func_for_two_args(b, p): async with finish() as f: bv = f.future(b._avalue) pv = f.future(p._avalue) return await _domethod('__pow__', bv.result(), pv.result())
async def func_for_two_args(l, r): async with finish() as f: lv = f.future(l._avalue) rv = f.future(r._avalue) return await _domethod('__truediv__', lv.result(), rv.result())
async def deriv_w_args(self, du: Variable, l: ValuedObj, r: ValuedObj) -> (ValuedObj, Undefined): async with finish() as f: ld = f.future(l._aderiv(du)) rd = f.future(r._aderiv(du)) return await (await ld).__asub__(await rd)