def OnEveryDt(x = None,dt = None):
from marketsim.gen._out._ifunction._ifunctionfloat import IFunctionfloat
from marketsim import rtti
if x is None or rtti.can_be_casted(x, IFunctionfloat):
if dt is None or rtti.can_be_casted(dt, float):
return OnEveryDt_FloatFloat(x,dt)
raise Exception('Cannot find suitable overload for OnEveryDt('+str(x) +':'+ str(type(x))+','+str(dt) +':'+ str(type(dt))+')')
def WithExpiry(proto=None, expiry=None):
from marketsim.gen._out._ifunction._ifunctionifunctioniobservableiorder_from_ifunctionfloat_from_ifunctionside import (
IFunctionIFunctionIObservableIOrder_from_IFunctionfloat_from_IFunctionSide,
)
from marketsim.gen._out._ifunction._ifunctionfloat import IFunctionfloat
from marketsim.gen._out.order._curried._side_price_withexpiry import (
side_price_WithExpiry_SideFloatIObservableIOrderFloat as _order__curried_side_price_WithExpiry_SideFloatIObservableIOrderFloat,
)
from marketsim import rtti
if proto is None or rtti.can_be_casted(
proto, IFunctionIFunctionIObservableIOrder_from_IFunctionfloat_from_IFunctionSide
):
if expiry is None or rtti.can_be_casted(expiry, IFunctionfloat):
return _order__curried_side_price_WithExpiry_SideFloatIObservableIOrderFloat(proto, expiry)
raise Exception(
"Cannot find suitable overload for WithExpiry("
+ str(proto)
+ ":"
+ str(type(proto))
+ ","
+ str(expiry)
+ ":"
+ str(type(expiry))
+ ")"
)
def MultiAsset(traders=None,
strategy=None,
name=None,
PnL=None,
timeseries=None):
from marketsim import rtti
from marketsim.gen._out._itimeserie import ITimeSerie
from marketsim.gen._out._isingleassettrader import ISingleAssetTrader
from marketsim import listOf
from marketsim.gen._out._imultiassetstrategy import IMultiAssetStrategy
if traders is None or rtti.can_be_casted(traders,
listOf(ISingleAssetTrader)):
if strategy is None or rtti.can_be_casted(strategy,
IMultiAssetStrategy):
if name is None or rtti.can_be_casted(name, str):
if PnL is None or rtti.can_be_casted(PnL, float):
if timeseries is None or rtti.can_be_casted(
timeseries, listOf(ITimeSerie)):
return MultiAsset_ListISingleAssetTraderIMultiAssetStrategyStringFloatListITimeSerie(
traders, strategy, name, PnL, timeseries)
raise Exception('Cannot find suitable overload for MultiAsset(' +
str(traders) + ':' + str(type(traders)) + ',' +
str(strategy) + ':' + str(type(strategy)) + ',' +
str(name) + ':' + str(type(name)) + ',' + str(PnL) + ':' +
str(type(PnL)) + ',' + str(timeseries) + ':' +
str(type(timeseries)) + ')')
def LogReturns(x = None,timeframe = None):
from marketsim.gen._out._iobservable._iobservablefloat import IObservablefloat
from marketsim import rtti
if x is None or rtti.can_be_casted(x, IObservablefloat):
if timeframe is None or rtti.can_be_casted(timeframe, float):
return LogReturns_IObservableFloatFloat(x,timeframe)
raise Exception('Cannot find suitable overload for LogReturns('+str(x) +':'+ str(type(x))+','+str(timeframe) +':'+ str(type(timeframe))+')')
def Pow(base = None,power = None):
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim import rtti
if base is None or rtti.can_be_casted(base, IFunctionfloat):
if power is None or rtti.can_be_casted(power, IFunctionfloat):
return Pow_FloatFloat(base,power)
raise Exception('Cannot find suitable overload for Pow('+str(base) +':'+ str(type(base))+','+str(power) +':'+ str(type(power))+')')
def C(x = None,p = None):
from marketsim.gen._out._ifunction import IFunctionICandleStick
from marketsim import rtti
if x is None or rtti.can_be_casted(x, IFunctionICandleStick):
if p is None or rtti.can_be_casted(p, int):
return C_ICandleStickInt(x,p)
raise Exception('Cannot find suitable overload for C('+str(x) +':'+ str(type(x))+','+str(p) +':'+ str(type(p))+')')
def Combine(A = None,B = None):
from marketsim.gen._out._isingleassetstrategy import ISingleAssetStrategy
from marketsim import rtti
if A is None or rtti.can_be_casted(A, ISingleAssetStrategy):
if B is None or rtti.can_be_casted(B, ISingleAssetStrategy):
return Combine_ISingleAssetStrategyISingleAssetStrategy(A,B)
raise Exception('Cannot find suitable overload for Combine('+str(A) +':'+ str(type(A))+','+str(B) +':'+ str(type(B))+')')
def Quote(ticker = None,start = None,end = None):
from marketsim import rtti
if ticker is None or rtti.can_be_casted(ticker, str):
if start is None or rtti.can_be_casted(start, str):
if end is None or rtti.can_be_casted(end, str):
return Quote_StringStringString(ticker,start,end)
raise Exception('Cannot find suitable overload for Quote('+str(ticker) +':'+ str(type(ticker))+','+str(start) +':'+ str(type(start))+','+str(end) +':'+ str(type(end))+')')
def WeightedPrice(queue = None,alpha = None):
from marketsim.gen._out._iorderqueue import IOrderQueue
from marketsim import rtti
if queue is None or rtti.can_be_casted(queue, IOrderQueue):
if alpha is None or rtti.can_be_casted(alpha, float):
return WeightedPrice_IOrderQueueFloat(queue,alpha)
raise Exception('Cannot find suitable overload for WeightedPrice('+str(queue) +':'+ str(type(queue))+','+str(alpha) +':'+ str(type(alpha))+')')
def LadderMM(orderFactory = None,initialSize = None):
from marketsim.gen._out._ifunction._ifunctioniobservableiorder_from_ifunctionsideifunctionfloat import IFunctionIObservableIOrder_from_IFunctionSideIFunctionfloat
from marketsim import rtti
if orderFactory is None or rtti.can_be_casted(orderFactory, IFunctionIObservableIOrder_from_IFunctionSideIFunctionfloat):
if initialSize is None or rtti.can_be_casted(initialSize, int):
return LadderMM_SideFloatIObservableIOrderInt(orderFactory,initialSize)
raise Exception('Cannot find suitable overload for LadderMM('+str(orderFactory) +':'+ str(type(orderFactory))+','+str(initialSize) +':'+ str(type(initialSize))+')')
def Var(source = None,alpha = None):
from marketsim.gen._out._iobservable import IObservablefloat
from marketsim import rtti
if source is None or rtti.can_be_casted(source, IObservablefloat):
if alpha is None or rtti.can_be_casted(alpha, float):
return Var_IObservableFloatFloat(source,alpha)
raise Exception('Cannot find suitable overload for Var('+str(source) +':'+ str(type(source))+','+str(alpha) +':'+ str(type(alpha))+')')
def TraderEfficiencyTrend(trader = None,alpha = None):
from marketsim.gen._out._iaccount import IAccount
from marketsim import rtti
if trader is None or rtti.can_be_casted(trader, IAccount):
if alpha is None or rtti.can_be_casted(alpha, float):
return TraderEfficiencyTrend_IAccountFloat(trader,alpha)
raise Exception('Cannot find suitable overload for TraderEfficiencyTrend('+str(trader) +':'+ str(type(trader))+','+str(alpha) +':'+ str(type(alpha))+')')
def LimitSigned(signedVolume = None,price = None):
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim import rtti
if signedVolume is None or rtti.can_be_casted(signedVolume, IFunctionfloat):
if price is None or rtti.can_be_casted(price, IFunctionfloat):
return LimitSigned_FloatFloat(signedVolume,price)
raise Exception('Cannot find suitable overload for LimitSigned('+str(signedVolume) +':'+ str(type(signedVolume))+','+str(price) +':'+ str(type(price))+')')
def MeanReversion(alpha = None,book = None):
from marketsim.gen._out._iorderbook import IOrderBook
from marketsim import rtti
if alpha is None or rtti.can_be_casted(alpha, float):
if book is None or rtti.can_be_casted(book, IOrderBook):
return MeanReversion_FloatIOrderBook(alpha,book)
raise Exception('Cannot find suitable overload for MeanReversion('+str(alpha) +':'+ str(type(alpha))+','+str(book) +':'+ str(type(book))+')')
def CSV(directory = None,source = None,attributes = None):
from marketsim import rtti
if directory is None or rtti.can_be_casted(directory, str):
if source is None or rtti.can_be_casted(source, object):
if attributes is None or rtti.can_be_casted(attributes, object):
return CSV_StringAnyAny(directory,source,attributes)
raise Exception('Cannot find suitable overload for CSV('+str(directory) +':'+ str(type(directory))+','+str(source) +':'+ str(type(source))+','+str(attributes) +':'+ str(type(attributes))+')')
def side_Limit(price = None,volume = None):
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim import rtti
if price is None or rtti.can_be_casted(price, IFunctionfloat):
if volume is None or rtti.can_be_casted(volume, IFunctionfloat):
return side_Limit_FloatFloat(price,volume)
raise Exception('Cannot find suitable overload for side_Limit('+str(price) +':'+ str(type(price))+','+str(volume) +':'+ str(type(volume))+')')
def FloatingPrice(proto=None, floatingPrice=None):
from marketsim.gen._out._ifunction._ifunctionifunctioniobservableiorder_from_ifunctionfloat_from_ifunctionside import (
IFunctionIFunctionIObservableIOrder_from_IFunctionfloat_from_IFunctionSide,
)
from marketsim.gen._out._iobservable._iobservablefloat import IObservablefloat
from marketsim.gen._out.order._curried._side_floatingprice import (
side_FloatingPrice_SideFloatIObservableIOrderIObservableFloat as _order__curried_side_FloatingPrice_SideFloatIObservableIOrderIObservableFloat,
)
from marketsim import rtti
if proto is None or rtti.can_be_casted(
proto, IFunctionIFunctionIObservableIOrder_from_IFunctionfloat_from_IFunctionSide
):
if floatingPrice is None or rtti.can_be_casted(floatingPrice, IObservablefloat):
return _order__curried_side_FloatingPrice_SideFloatIObservableIOrderIObservableFloat(proto, floatingPrice)
raise Exception(
"Cannot find suitable overload for FloatingPrice("
+ str(proto)
+ ":"
+ str(type(proto))
+ ","
+ str(floatingPrice)
+ ":"
+ str(type(floatingPrice))
+ ")"
)
def StdDev(source = None,timeframe = None):
from marketsim.gen._out._iobservable import IObservablefloat
from marketsim import rtti
if source is None or rtti.can_be_casted(source, IObservablefloat):
if timeframe is None or rtti.can_be_casted(timeframe, float):
return StdDev_IObservableFloatFloat(source,timeframe)
raise Exception('Cannot find suitable overload for StdDev('+str(source) +':'+ str(type(source))+','+str(timeframe) +':'+ str(type(timeframe))+')')
def AtanPow(f = None,base = None):
from marketsim.gen._out._ifunction._ifunctionfloat import IFunctionfloat
from marketsim import rtti
if f is None or rtti.can_be_casted(f, IFunctionfloat):
if base is None or rtti.can_be_casted(base, float):
return AtanPow_FloatFloat(f,base)
raise Exception('Cannot find suitable overload for AtanPow('+str(f) +':'+ str(type(f))+','+str(base) +':'+ str(type(base))+')')
def WeightedPrice(book = None,alpha = None):
from marketsim.gen._out._iorderbook import IOrderBook
from marketsim import rtti
if book is None or rtti.can_be_casted(book, IOrderBook):
if alpha is None or rtti.can_be_casted(alpha, float):
return WeightedPrice_IOrderBookFloat(book,alpha)
raise Exception('Cannot find suitable overload for WeightedPrice('+str(book) +':'+ str(type(book))+','+str(alpha) +':'+ str(type(alpha))+')')
def const(x = None):
from marketsim import rtti
if x is None or rtti.can_be_casted(x, int):
return const_Int(x)
if x is None or rtti.can_be_casted(x, float):
return const_Float(x)
raise Exception('Cannot find suitable overload for const('+str(x) +':'+ str(type(x))+')')
def AtanPow(f = None,base = None):
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim import rtti
if f is None or rtti.can_be_casted(f, IFunctionfloat):
if base is None or rtti.can_be_casted(base, float):
return AtanPow_FloatFloat(f,base)
raise Exception('Cannot find suitable overload for AtanPow('+str(f) +':'+ str(type(f))+','+str(base) +':'+ str(type(base))+')')
def DownMovements(source = None,timeframe = None):
from marketsim.gen._out._iobservable import IObservablefloat
from marketsim import rtti
if source is None or rtti.can_be_casted(source, IObservablefloat):
if timeframe is None or rtti.can_be_casted(timeframe, float):
return DownMovements_IObservableFloatFloat(source,timeframe)
raise Exception('Cannot find suitable overload for DownMovements('+str(source) +':'+ str(type(source))+','+str(timeframe) +':'+ str(type(timeframe))+')')
def triangular(Low = None,High = None,Mode = None):
from marketsim import rtti
if Low is None or rtti.can_be_casted(Low, float):
if High is None or rtti.can_be_casted(High, float):
if Mode is None or rtti.can_be_casted(Mode, float):
return triangular_FloatFloatFloat(Low,High,Mode)
raise Exception('Cannot find suitable overload for triangular('+str(Low) +':'+ str(type(Low))+','+str(High) +':'+ str(type(High))+','+str(Mode) +':'+ str(type(Mode))+')')
def TwoWayLink(up = None,down = None):
from marketsim.gen._out._ilink import ILink
from marketsim import rtti
if up is None or rtti.can_be_casted(up, ILink):
if down is None or rtti.can_be_casted(down, ILink):
return TwoWayLink_ILinkILink(up,down)
raise Exception('Cannot find suitable overload for TwoWayLink('+str(up) +':'+ str(type(up))+','+str(down) +':'+ str(type(down))+')')
def AsksImpl(tickSize = None,book = None):
from marketsim.gen._out._iorderbook import IOrderBook
from marketsim import rtti
if tickSize is None or rtti.can_be_casted(tickSize, float):
if book is None or rtti.can_be_casted(book, IOrderBook):
return AsksImpl_FloatIOrderBook(tickSize,book)
raise Exception('Cannot find suitable overload for AsksImpl('+str(tickSize) +':'+ str(type(tickSize))+','+str(book) +':'+ str(type(book))+')')
def LadderBalancer(inner = None,maximalSize = None):
from marketsim.gen._out._iladderstrategy import ILadderStrategy
from marketsim import rtti
if inner is None or rtti.can_be_casted(inner, ILadderStrategy):
if maximalSize is None or rtti.can_be_casted(maximalSize, int):
return LadderBalancer_ILadderStrategyInt(inner,maximalSize)
raise Exception('Cannot find suitable overload for LadderBalancer('+str(inner) +':'+ str(type(inner))+','+str(maximalSize) +':'+ str(type(maximalSize))+')')
def lognormvariate(Mu=None, Sigma=None):
from marketsim import rtti
if Mu is None or rtti.can_be_casted(Mu, float):
if Sigma is None or rtti.can_be_casted(Sigma, float):
return lognormvariate_FloatFloat(Mu, Sigma)
raise Exception('Cannot find suitable overload for lognormvariate(' +
str(Mu) + ':' + str(type(Mu)) + ',' + str(Sigma) + ':' +
str(type(Sigma)) + ')')
def side_price_Iceberg(proto = None,lotSize = None):
from marketsim.gen._out._ifunction import IFunctionIFunctionIObservableIOrderIFunctionfloatIFunctionSide
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim import rtti
if proto is None or rtti.can_be_casted(proto, IFunctionIFunctionIObservableIOrderIFunctionfloatIFunctionSide):
if lotSize is None or rtti.can_be_casted(lotSize, IFunctionfloat):
return side_price_Iceberg_SideFloatIObservableIOrderFloat(proto,lotSize)
raise Exception('Cannot find suitable overload for side_price_Iceberg('+str(proto) +':'+ str(type(proto))+','+str(lotSize) +':'+ str(type(lotSize))+')')
def sidevolume_WithExpiry(expiry = None,proto = None):
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim.gen._out._ifunction import IFunctionIObservableIOrderIFunctionSideIFunctionfloat
from marketsim import rtti
if expiry is None or rtti.can_be_casted(expiry, IFunctionfloat):
if proto is None or rtti.can_be_casted(proto, IFunctionIObservableIOrderIFunctionSideIFunctionfloat):
return sidevolume_WithExpiry_FloatSideFloatIObservableIOrder(expiry,proto)
raise Exception('Cannot find suitable overload for sidevolume_WithExpiry('+str(expiry) +':'+ str(type(expiry))+','+str(proto) +':'+ str(type(proto))+')')
def FloatingPrice(proto = None,floatingPrice = None):
from marketsim.gen._out._ifunction._ifunctioniobservableiorder_from_ifunctionfloat import IFunctionIObservableIOrder_from_IFunctionfloat
from marketsim.gen._out._iobservable._iobservablefloat import IObservablefloat
from marketsim import rtti
if proto is None or rtti.can_be_casted(proto, IFunctionIObservableIOrder_from_IFunctionfloat):
if floatingPrice is None or rtti.can_be_casted(floatingPrice, IObservablefloat):
return FloatingPrice_FloatIObservableIOrderIObservableFloat(proto,floatingPrice)
raise Exception('Cannot find suitable overload for FloatingPrice('+str(proto) +':'+ str(type(proto))+','+str(floatingPrice) +':'+ str(type(floatingPrice))+')')
def side_price_WithExpiry(proto = None,expiry = None):
from marketsim.gen._out._ifunction._ifunctionifunctioniobservableiorder_from_ifunctionfloat_from_ifunctionside import IFunctionIFunctionIObservableIOrder_from_IFunctionfloat_from_IFunctionSide
from marketsim.gen._out._ifunction._ifunctionfloat import IFunctionfloat
from marketsim import rtti
if proto is None or rtti.can_be_casted(proto, IFunctionIFunctionIObservableIOrder_from_IFunctionfloat_from_IFunctionSide):
if expiry is None or rtti.can_be_casted(expiry, IFunctionfloat):
return side_price_WithExpiry_SideFloatIObservableIOrderFloat(proto,expiry)
raise Exception('Cannot find suitable overload for side_price_WithExpiry('+str(proto) +':'+ str(type(proto))+','+str(expiry) +':'+ str(type(expiry))+')')
def LessThan(bound=None, target=None):
from marketsim import rtti
if bound is None or rtti.can_be_casted(bound, float):
if target is None or rtti.can_be_casted(target, object):
return LessThan_FloatAny(bound, target)
raise Exception('Cannot find suitable overload for LessThan(' +
str(bound) + ':' + str(type(bound)) + ',' + str(target) +
':' + str(type(target)) + ')')
def side_StopLoss(proto = None,maxloss = None):
from marketsim.gen._out._ifunction._ifunctioniobservableiorder_from_ifunctionside import IFunctionIObservableIOrder_from_IFunctionSide
from marketsim.gen._out._ifunction._ifunctionfloat import IFunctionfloat
from marketsim import rtti
if proto is None or rtti.can_be_casted(proto, IFunctionIObservableIOrder_from_IFunctionSide):
if maxloss is None or rtti.can_be_casted(maxloss, IFunctionfloat):
return side_StopLoss_SideIObservableIOrderFloat(proto,maxloss)
raise Exception('Cannot find suitable overload for side_StopLoss('+str(proto) +':'+ str(type(proto))+','+str(maxloss) +':'+ str(type(maxloss))+')')
def VolumeLevelProxy(source=None, idx=None):
from marketsim import rtti
if source is None or rtti.can_be_casted(source, object):
if idx is None or rtti.can_be_casted(idx, int):
return VolumeLevelProxy_AnyInt(source, idx)
raise Exception('Cannot find suitable overload for VolumeLevelProxy(' +
str(source) + ':' + str(type(source)) + ',' + str(idx) +
':' + str(type(idx)) + ')')
def MarketMaker(delta=None, volume=None):
from marketsim import rtti
if delta is None or rtti.can_be_casted(delta, float):
if volume is None or rtti.can_be_casted(volume, float):
return MarketMaker_FloatFloat(delta, volume)
raise Exception('Cannot find suitable overload for MarketMaker(' +
str(delta) + ':' + str(type(delta)) + ',' + str(volume) +
':' + str(type(volume)) + ')')
def betavariate(Alpha=None, Beta=None):
from marketsim import rtti
if Alpha is None or rtti.can_be_casted(Alpha, float):
if Beta is None or rtti.can_be_casted(Beta, float):
return betavariate_FloatFloat(Alpha, Beta)
raise Exception('Cannot find suitable overload for betavariate(' +
str(Alpha) + ':' + str(type(Alpha)) + ',' + str(Beta) +
':' + str(type(Beta)) + ')')
def DesiredPosition(desiredPosition = None,trader = None):
from marketsim.gen._out._iobservable import IObservablefloat
from marketsim.gen._out._isingleassettrader import ISingleAssetTrader
from marketsim import rtti
if desiredPosition is None or rtti.can_be_casted(desiredPosition, IObservablefloat):
if trader is None or rtti.can_be_casted(trader, ISingleAssetTrader):
return DesiredPosition_IObservableFloatISingleAssetTrader(desiredPosition,trader)
raise Exception('Cannot find suitable overload for DesiredPosition('+str(desiredPosition) +':'+ str(type(desiredPosition))+','+str(trader) +':'+ str(type(trader))+')')
def vonmisesvariate(Mu=None, Kappa=None):
from marketsim import rtti
if Mu is None or rtti.can_be_casted(Mu, float):
if Kappa is None or rtti.can_be_casted(Kappa, float):
return vonmisesvariate_FloatFloat(Mu, Kappa)
raise Exception('Cannot find suitable overload for vonmisesvariate(' +
str(Mu) + ':' + str(type(Mu)) + ',' + str(Kappa) + ':' +
str(type(Kappa)) + ')')
def VolumeLevels(queue = None,volumeDelta = None,volumeCount = None):
from marketsim.gen._out._iorderqueue import IOrderQueue
from marketsim import rtti
if queue is None or rtti.can_be_casted(queue, IOrderQueue):
if volumeDelta is None or rtti.can_be_casted(volumeDelta, float):
if volumeCount is None or rtti.can_be_casted(volumeCount, int):
return VolumeLevels_IOrderQueueFloatInt(queue,volumeDelta,volumeCount)
raise Exception('Cannot find suitable overload for VolumeLevels('+str(queue) +':'+ str(type(queue))+','+str(volumeDelta) +':'+ str(type(volumeDelta))+','+str(volumeCount) +':'+ str(type(volumeCount))+')')
def Price(x = None,side = None):
from marketsim.gen._out.strategy.price._liquidityprovider import LiquidityProvider
from marketsim.gen._out._ifunction._ifunctionside import IFunctionSide
from marketsim import rtti
if x is None or rtti.can_be_casted(x, LiquidityProvider):
if side is None or rtti.can_be_casted(side, IFunctionSide):
return Price_strategypriceLiquidityProviderSide(x,side)
raise Exception('Cannot find suitable overload for Price('+str(x) +':'+ str(type(x))+','+str(side) +':'+ str(type(side))+')')
def uniform(Low=None, High=None):
from marketsim import rtti
if Low is None or rtti.can_be_casted(Low, float):
if High is None or rtti.can_be_casted(High, float):
return uniform_FloatFloat(Low, High)
raise Exception('Cannot find suitable overload for uniform(' + str(Low) +
':' + str(type(Low)) + ',' + str(High) + ':' +
str(type(High)) + ')')
def TrendFollower(alpha = None,threshold = None,book = None):
from marketsim.gen._out._iorderbook import IOrderBook
from marketsim import rtti
if alpha is None or rtti.can_be_casted(alpha, float):
if threshold is None or rtti.can_be_casted(threshold, float):
if book is None or rtti.can_be_casted(book, IOrderBook):
return TrendFollower_FloatFloatIOrderBook(alpha,threshold,book)
raise Exception('Cannot find suitable overload for TrendFollower('+str(alpha) +':'+ str(type(alpha))+','+str(threshold) +':'+ str(type(threshold))+','+str(book) +':'+ str(type(book))+')')
def sidevolume_price_StopLoss(maxloss = None,proto = None):
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim.gen._out._ifunction import IFunctionIFunctionIObservableIOrderIFunctionfloatIFunctionSideIFunctionfloat
from marketsim import rtti
if maxloss is None or rtti.can_be_casted(maxloss, IFunctionfloat):
if proto is None or rtti.can_be_casted(proto, IFunctionIFunctionIObservableIOrderIFunctionfloatIFunctionSideIFunctionfloat):
return sidevolume_price_StopLoss_FloatSideFloatFloatIObservableIOrder(maxloss,proto)
raise Exception('Cannot find suitable overload for sidevolume_price_StopLoss('+str(maxloss) +':'+ str(type(maxloss))+','+str(proto) +':'+ str(type(proto))+')')
def sideprice_Iceberg(proto = None,lotSize = None):
from marketsim.gen._out._ifunction._ifunctioniobservableiorder_from_ifunctionsideifunctionfloat import IFunctionIObservableIOrder_from_IFunctionSideIFunctionfloat
from marketsim.gen._out._ifunction._ifunctionfloat import IFunctionfloat
from marketsim import rtti
if proto is None or rtti.can_be_casted(proto, IFunctionIObservableIOrder_from_IFunctionSideIFunctionfloat):
if lotSize is None or rtti.can_be_casted(lotSize, IFunctionfloat):
return sideprice_Iceberg_SideFloatIObservableIOrderFloat(proto,lotSize)
raise Exception('Cannot find suitable overload for sideprice_Iceberg('+str(proto) +':'+ str(type(proto))+','+str(lotSize) +':'+ str(type(lotSize))+')')
def CumulativePrice(book = None,depth = None):
from marketsim.gen._out._iorderbook import IOrderBook
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim import rtti
if book is None or rtti.can_be_casted(book, IOrderBook):
if depth is None or rtti.can_be_casted(depth, IFunctionfloat):
return CumulativePrice_IOrderBookFloat(book,depth)
raise Exception('Cannot find suitable overload for CumulativePrice('+str(book) +':'+ str(type(book))+','+str(depth) +':'+ str(type(depth))+')')
def side_price_FloatingPrice(floatingPrice = None,proto = None):
from marketsim.gen._out._iobservable import IObservablefloat
from marketsim.gen._out._ifunction import IFunctionIFunctionIObservableIOrderIFunctionfloatIFunctionSide
from marketsim import rtti
if floatingPrice is None or rtti.can_be_casted(floatingPrice, IObservablefloat):
if proto is None or rtti.can_be_casted(proto, IFunctionIFunctionIObservableIOrderIFunctionfloatIFunctionSide):
return side_price_FloatingPrice_IObservableFloatSideFloatIObservableIOrder(floatingPrice,proto)
raise Exception('Cannot find suitable overload for side_price_FloatingPrice('+str(floatingPrice) +':'+ str(type(floatingPrice))+','+str(proto) +':'+ str(type(proto))+')')
def A(x=None, y=None):
from marketsim.gen._out._ifunction import IFunctionint
from marketsim.gen._out._ifunction import IFunctionfloat
from marketsim import rtti
if x is None or rtti.can_be_casted(x, IFunctionint):
if y is None or rtti.can_be_casted(y, IFunctionfloat):
return A_IntFloat(x, y)
raise Exception('Cannot find suitable overload for A(' + str(x) + ':' +
str(type(x)) + ',' + str(y) + ':' + str(type(y)) + ')')
def Var(source=None, alpha=None):
from marketsim.gen._out._iobservable import IObservablefloat
from marketsim import rtti
if source is None or rtti.can_be_casted(source, IObservablefloat):
if alpha is None or rtti.can_be_casted(alpha, float):
return Var_IObservableFloatFloat(source, alpha)
raise Exception('Cannot find suitable overload for Var(' + str(source) +
':' + str(type(source)) + ',' + str(alpha) + ':' +
str(type(alpha)) + ')')
def Alpha(x = None):
from marketsim.gen._out.math._ew import EW
from marketsim.gen._out.math._rsi import RSI
from marketsim import rtti
if x is None or rtti.can_be_casted(x, EW):
return Alpha_mathEW(x)
if x is None or rtti.can_be_casted(x, RSI):
return Alpha_mathRSI(x)
raise Exception('Cannot find suitable overload for Alpha('+str(x) +':'+ str(type(x))+')')
def FloatingPrice(floatingPrice = None,proto = None):
from marketsim.gen._out._iobservable import IObservablefloat
from marketsim.gen._out._ifunction import IFunctionIFunctionIObservableIOrderIFunctionfloatIFunctionSideIFunctionfloat
from marketsim.gen._out.order._curried._sidevolume_floatingprice import sidevolume_FloatingPrice_IObservableFloatSideFloatFloatIObservableIOrder as _order__curried_sidevolume_FloatingPrice_IObservableFloatSideFloatFloatIObservableIOrder
from marketsim import rtti
if floatingPrice is None or rtti.can_be_casted(floatingPrice, IObservablefloat):
if proto is None or rtti.can_be_casted(proto, IFunctionIFunctionIObservableIOrderIFunctionfloatIFunctionSideIFunctionfloat):
return _order__curried_sidevolume_FloatingPrice_IObservableFloatSideFloatFloatIObservableIOrder(floatingPrice,proto)
raise Exception('Cannot find suitable overload for FloatingPrice('+str(floatingPrice) +':'+ str(type(floatingPrice))+','+str(proto) +':'+ str(type(proto))+')')
