Exemplo n.º 1
0
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))+')')
Exemplo n.º 2
0
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))
        + ")"
    )
Exemplo n.º 3
0
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)) + ')')
Exemplo n.º 4
0
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))+')')
Exemplo n.º 5
0
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))+')')
Exemplo n.º 6
0
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))+')')
Exemplo n.º 7
0
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))+')')
Exemplo n.º 8
0
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))+')')
Exemplo n.º 9
0
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))+')')
Exemplo n.º 10
0
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))+')')
Exemplo n.º 11
0
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))+')')
Exemplo n.º 12
0
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))+')')
Exemplo n.º 13
0
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))+')')
Exemplo n.º 14
0
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))+')')
Exemplo n.º 15
0
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))+')')
Exemplo n.º 16
0
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))+')')
Exemplo n.º 17
0
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))
        + ")"
    )
Exemplo n.º 18
0
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))+')')
Exemplo n.º 19
0
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))+')')
Exemplo n.º 20
0
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))+')')
Exemplo n.º 21
0
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))+')')
Exemplo n.º 22
0
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))+')')
Exemplo n.º 23
0
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))+')')
Exemplo n.º 24
0
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))+')')
Exemplo n.º 25
0
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))+')')
Exemplo n.º 26
0
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))+')')
Exemplo n.º 27
0
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))+')')
Exemplo n.º 28
0
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))+')')
Exemplo n.º 31
0
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))+')')
Exemplo n.º 32
0
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))+')')
Exemplo n.º 33
0
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)) + ')')
Exemplo n.º 34
0
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))+')')
Exemplo n.º 35
0
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)) + ')')
Exemplo n.º 36
0
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)) + ')')
Exemplo n.º 37
0
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)) + ')')
Exemplo n.º 38
0
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))+')')
Exemplo n.º 39
0
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)) + ')')
Exemplo n.º 40
0
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))+')')
Exemplo n.º 41
0
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))+')')
Exemplo n.º 42
0
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)) + ')')
Exemplo n.º 43
0
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))+')')
Exemplo n.º 46
0
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))+')')
Exemplo n.º 48
0
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)) + ')')
Exemplo n.º 49
0
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)) + ')')
Exemplo n.º 50
0
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))+')')
Exemplo n.º 51
0
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))+')')