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)
