class IFunctionIEvent_from_IFunctionSideIFunctionfloat(object): _types = [meta.function(( IFunctionSide, IFunctionfloat, ), IEvent)] _types.append(IFunctionobject_from_IFunctionSideIFunctionfloat) pass
class IFunctionobject_from_IFunctionSideIFunctionfloat(object): _types = [meta.function(( IFunctionSide, IFunctionfloat, ), object)] pass
class IFunctionIFunctionIObservableIOrder_from_IFunctionfloat_from_IFunctionSide( object): _types = [ meta.function((IFunctionSide, ), IFunctionIObservableIOrder_from_IFunctionfloat) ] _types.append(IFunctionobject_from_IFunctionSide) _types.append( IFunctionIFunctionobject_from_IFunctionfloat_from_IFunctionSide) _types.append( IFunctionIFunctionIFunctionIOrder_from_IFunctionfloat_from_IFunctionSide ) _types.append( IFunctionIFunctionIEvent_from_IFunctionfloat_from_IFunctionSide) def side_price_StopLoss(self, maxloss=None): from marketsim.gen._out.order._curried._side_price_stoploss import side_price_StopLoss return side_price_StopLoss(self, maxloss) def sideprice_FloatingPrice(self, floatingPrice=None): from marketsim.gen._out.order._curried._sideprice_floatingprice import sideprice_FloatingPrice return sideprice_FloatingPrice(self, floatingPrice) @property def sideprice_Peg(self): from marketsim.gen._out.order._curried._sideprice_peg import sideprice_Peg return sideprice_Peg(self) @property def side_Peg(self): from marketsim.gen._out.order._curried._side_peg import side_Peg return side_Peg(self) def side_price_Iceberg(self, lotSize=None): from marketsim.gen._out.order._curried._side_price_iceberg import side_price_Iceberg return side_price_Iceberg(self, lotSize) @property def side_price_ImmediateOrCancel(self): from marketsim.gen._out.order._curried._side_price_immediateorcancel import side_price_ImmediateOrCancel return side_price_ImmediateOrCancel(self) def side_price_FloatingPrice(self, floatingPrice=None): from marketsim.gen._out.order._curried._side_price_floatingprice import side_price_FloatingPrice return side_price_FloatingPrice(self, floatingPrice) def side_FloatingPrice(self, floatingPrice=None): from marketsim.gen._out.order._curried._side_floatingprice import side_FloatingPrice return side_FloatingPrice(self, floatingPrice) def side_price_WithExpiry(self, expiry=None): from marketsim.gen._out.order._curried._side_price_withexpiry import side_price_WithExpiry return side_price_WithExpiry(self, expiry) @property def side_price_Peg(self): from marketsim.gen._out.order._curried._side_price_peg import side_price_Peg return side_price_Peg(self) pass
class IFunctionIFunctionIFunctionobject_from_IFunctionfloat_from_IFunctionSide( object): _types = [ meta.function((IFunctionSide, ), IFunctionIFunctionobject_from_IFunctionfloat) ] _types.append(IFunctionobject_from_IFunctionSide) _types.append( IFunctionIFunctionobject_from_IFunctionfloat_from_IFunctionSide) pass
class IFunctionbool(Function_impl): _types = [meta.function((), bool)] _types.append(IFunctionobject) def And(self, y=None): from marketsim.gen._out.ops._and import And return And(self, y) def Or(self, y=None): from marketsim.gen._out.ops._or import Or return Or(self, y) def Condition(self, ifpart=None, elsepart=None): from marketsim.gen._out.ops._condition import Condition return Condition(self, ifpart, elsepart) pass
class IFunctionSide(object): _types = [meta.function((), Side)] _types.append(IFunctionobject) def price_Limit(self, volume=None): from marketsim.gen._out.order._curried._price_limit import price_Limit return price_Limit(self, volume) def Limit(self, price=None, volume=None): from marketsim.gen._out.order._limit import Limit return Limit(self, price, volume) def Market(self, volume=None): from marketsim.gen._out.order._market import Market return Market(self, volume) def FixedBudget(self, budget=None): from marketsim.gen._out.order._fixedbudget import FixedBudget return FixedBudget(self, budget) pass
class IFunctionIObservableIOrder_from_IFunctionSideIFunctionfloat(object): _types = [ meta.function(( IFunctionSide, IFunctionfloat, ), IObservableIOrder) ] _types.append(IFunctionobject_from_IFunctionSideIFunctionfloat) _types.append(IFunctionIFunctionIOrder_from_IFunctionSideIFunctionfloat) _types.append(IFunctionIEvent_from_IFunctionSideIFunctionfloat) def sideprice_StopLoss(self, maxloss=None): from marketsim.gen._out.order._curried._sideprice_stoploss import sideprice_StopLoss return sideprice_StopLoss(self, maxloss) def Ladder(self, initialSize=None, side=None): from marketsim.gen._out.strategy.price._ladder import Ladder return Ladder(self, initialSize, side) def sideprice_WithExpiry(self, expiry=None): from marketsim.gen._out.order._curried._sideprice_withexpiry import sideprice_WithExpiry return sideprice_WithExpiry(self, expiry) def LadderMM(self, initialSize=None): from marketsim.gen._out.strategy.price._laddermm import LadderMM return LadderMM(self, initialSize) def sideprice_Iceberg(self, lotSize=None): from marketsim.gen._out.order._curried._sideprice_iceberg import sideprice_Iceberg return sideprice_Iceberg(self, lotSize) @property def sideprice_ImmediateOrCancel(self): from marketsim.gen._out.order._curried._sideprice_immediateorcancel import sideprice_ImmediateOrCancel return sideprice_ImmediateOrCancel(self) pass
class IFunctionIFunctionIOrder_from_IFunctionfloat(object): _types = [meta.function((IFunctionfloat, ), IFunctionIOrder)] _types.append(IFunctionobject_from_IFunctionfloat) _types.append(IFunctionIFunctionobject_from_IFunctionfloat) pass
class IFunctionICandleStick(object): _types = [meta.function((), ICandleStick)] _types.append(IFunctionobject) pass
class IFunctionIFunctionlistOffloat_from_listOffloat(object): _types = [meta.function((listOf(float), ), IFunctionlistOffloat)] _types.append(IFunctionobject_from_listOffloat) _types.append(IFunctionIFunctionobject_from_listOffloat) _types.append(IFunctionIFunctionlistOfobject_from_listOffloat) pass
class IFunctionIAccount_from_ISingleAssetStrategy(object): _types = [meta.function((ISingleAssetStrategy, ), IAccount)] _types.append(IFunctionobject_from_ISingleAssetStrategy) pass
class IFunctionobject_from_IFunctionSide(object): _types = [meta.function((IFunctionSide,),object)] pass
def processIn(self, book): """ Called when an order book tries to determine how the order should be processed """ self._book = book self._tryToResend() def iceberg(volumeLimit, orderFactory): """ Returns a function to create iceberg orders with given volumeLimit and orderFactory to create real orders """ def inner(*args): return Iceberg(volumeLimit, orderFactory, *args) return inner LimitOrderFactorySignature = meta.function((types.Side,), meta.function((types.Price, types.Volume), types.IOrder)) @registry.expose(['Iceberg']) class IcebergFactory(object): """ Virtual order that implements iceberg strategy: First it sends an order for a small potion of its volume to a book and once it is filled resends a new order """ def __init__(self, volumeLimit = 10, orderFactory = LimitFactory): self.volumeLimit = volumeLimit self.orderFactory = orderFactory _types = [LimitOrderFactorySignature] _properties = {'volumeLimit' : int,
class IFunctionobject(object): _types = [meta.function((), object)] pass
class IFunctionlistOffloat(object): _types = [meta.function((), listOf(float))] _types.append(IFunctionobject) _types.append(IFunctionlistOfobject) pass
class IFunctionobject_from_listOffloat(object): _types = [meta.function((listOf(float),),object)] pass
class IFunctionobject_from_IAccount(object): _types = [meta.function((IAccount, ), object)] pass
class IFunctionint(Function_impl): _types = [meta.function((), int)] _types.append(IFunctionobject) _types.append(IFunctionfloat) pass
class IFunctionIOrder(object): _types = [meta.function((),IOrder)] _types.append(IFunctionobject) pass
class IFunctionIFunctionfloat_from_IAccount(object): _types = [meta.function((IAccount, ), IFunctionfloat)] _types.append(IFunctionobject_from_IAccount) _types.append(IFunctionIFunctionobject_from_IAccount) pass
@registry.expose(alias=['AtanPow']) @meta.sig(args=(types.IFunction[float],), rv=types.IFunction[float]) def atanpow(f, base = 1.002): return ops.Atan(ops.Pow(ops.constant(base), f)) @registry.expose(alias=['Clamp0']) @meta.sig(args=(types.IFunction[float],), rv=types.IFunction[float]) def clamp0(f): return ops.Max(f, ops.constant(0)) + 1 def identity(x): return x Ts = [float, meta.listOf(float), types.IFunction[float]] identity._types = [meta.function((t,), t) for t in Ts] registry.expose(alias=['identity'])(identity) def cachedattr(obj, name, setter): if not hasattr(obj, name): setattr(obj, name, setter()) return getattr(obj, name) @registry.expose(alias=['Efficiency']) @meta.sig(args=(types.IAccount,), rv=types.IFunction[float]) def efficiency(trader): return cachedattr(trader, '_efficiency', lambda: observable.Efficiency(trader))
class IFunctionfloat(Function_impl): _types = [meta.function((), float)] _types.append(IFunctionobject) @property def Negate(self): from marketsim.gen._out.ops._negate import Negate return Negate(self) def OnEveryDt(self, dt=None): from marketsim.gen._out.observable._oneverydt import OnEveryDt return OnEveryDt(self, dt) def Min(self, y=None): from marketsim.gen._out.math._min import Min return Min(self, y) @property def side_FixedBudget(self): from marketsim.gen._out.order._curried._side_fixedbudget import side_FixedBudget return side_FixedBudget(self) @property def sideprice_Limit(self): from marketsim.gen._out.order._curried._sideprice_limit import sideprice_Limit return sideprice_Limit(self) def Signal(self, threshold=None): from marketsim.gen._out.strategy.side._signal import Signal return Signal(self, threshold) @property def signedVolume_LimitSigned(self): from marketsim.gen._out.order._curried._signedvolume_limitsigned import signedVolume_LimitSigned return signedVolume_LimitSigned(self) def Add(self, y=None): from marketsim.gen._out.ops._add import Add return Add(self, y) @property def Atan(self): from marketsim.gen._out.math._atan import Atan return Atan(self) def Less(self, y=None): from marketsim.gen._out.ops._less import Less return Less(self, y) @property def FundamentalValue(self): from marketsim.gen._out.strategy.side._fundamentalvalue import FundamentalValue return FundamentalValue(self) @property def MarketSigned(self): from marketsim.gen._out.order._marketsigned import MarketSigned return MarketSigned(self) def Mul(self, y=None): from marketsim.gen._out.ops._mul import Mul return Mul(self, y) def NotEqual(self, y=None): from marketsim.gen._out.ops._notequal import NotEqual return NotEqual(self, y) def Max(self, y=None): from marketsim.gen._out.math._max import Max return Max(self, y) @property def Sqr(self): from marketsim.gen._out.math._sqr import Sqr return Sqr(self) @property def Sqrt(self): from marketsim.gen._out.math._sqrt import Sqrt return Sqrt(self) def GreaterEqual(self, y=None): from marketsim.gen._out.ops._greaterequal import GreaterEqual return GreaterEqual(self, y) def side_Limit(self, volume=None): from marketsim.gen._out.order._curried._side_limit import side_Limit return side_Limit(self, volume) @property def Exp(self): from marketsim.gen._out.math._exp import Exp return Exp(self) @property def Log(self): from marketsim.gen._out.math._log import Log return Log(self) def getOrElse(self, elsePart=None): from marketsim.gen._out._ifdefined import IfDefined return IfDefined(self, elsePart) @property def side_price_Limit(self): from marketsim.gen._out.order._curried._side_price_limit import side_price_Limit return side_price_Limit(self) @property def isLossTooHigh(self): from marketsim.gen._out.strategy.price._islosstoohigh import isLossTooHigh return isLossTooHigh(self) @property def side_Market(self): from marketsim.gen._out.order._curried._side_market import side_Market return side_Market(self) @property def Clamp0(self): from marketsim.gen._out.strategy.weight._clamp0 import Clamp0 return Clamp0(self) @property def Canceller(self): from marketsim.gen._out.strategy._canceller import Canceller return Canceller(self) def Sub(self, y=None): from marketsim.gen._out.ops._sub import Sub return Sub(self, y) def AtanPow(self, base=None): from marketsim.gen._out.strategy.weight._atanpow import AtanPow return AtanPow(self, base) def Pow(self, power=None): from marketsim.gen._out.math._pow import Pow return Pow(self, power) def LimitSigned(self, price=None): from marketsim.gen._out.order._limitsigned import LimitSigned return LimitSigned(self, price) @property def Noise(self): from marketsim.gen._out.strategy.side._noise import Noise return Noise(self) @property def IdentityF(self): from marketsim.gen._out.strategy.weight._identityf import IdentityF return IdentityF(self) def Div(self, y=None): from marketsim.gen._out.ops._div import Div return Div(self, y) def LessEqual(self, y=None): from marketsim.gen._out.ops._lessequal import LessEqual return LessEqual(self, y) def Equal(self, y=None): from marketsim.gen._out.ops._equal import Equal return Equal(self, y) def Greater(self, y=None): from marketsim.gen._out.ops._greater import Greater return Greater(self, y) pass
class IFunctionobject_from_ISingleAssetStrategy(object): _types = [meta.function((ISingleAssetStrategy, ), object)] pass
class IFunctionIVolumeLevels(object): _types = [meta.function((),IVolumeLevels)] _types.append(IFunctionobject) pass