def __init__(self, base = None, power = None):
     from marketsim.gen._out._observable._observablefloat import Observablefloat
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import deref_opt
     Observablefloat.__init__(self)
     self.base = base if base is not None else deref_opt(_constant_Float(1.0))
     self.power = power if power is not None else deref_opt(_constant_Float(1.0))

 def getImpl(self):
     from marketsim.gen._out.orderbook._midprice import MidPrice_IOrderBook as _orderbook_MidPrice_IOrderBook
     from marketsim.gen._out.ops._div import Div_FloatFloat as _ops_Div_FloatFloat
     from marketsim.gen._out.math.rsi._raw import Raw_IObservableFloatFloatFloat as _math_rsi_Raw_IObservableFloatFloatFloat
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim.gen._out.ops._add import Add_FloatFloat as _ops_Add_FloatFloat
     from marketsim.gen._out.ops._sub import Sub_FloatFloat as _ops_Sub_FloatFloat
     return _ops_Sub_FloatFloat(_constant_Float(100.0),_ops_Div_FloatFloat(_constant_Float(100.0),_ops_Add_FloatFloat(_constant_Float(1.0),_math_rsi_Raw_IObservableFloatFloatFloat(_orderbook_MidPrice_IOrderBook(self.book),self.timeframe,self.alpha))))

 def __init__(self, x = None, y = None):
     from marketsim.gen._out._observable._observablebool import Observablebool
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import deref_opt
     Observablebool.__init__(self)
     self.x = x if x is not None else deref_opt(_constant_Float(1.0))
     self.y = y if y is not None else deref_opt(_constant_Float(1.0))
     Greater_Impl.__init__(self)

 def __init__(self, signedVolume = None, price = None):
     from marketsim.gen._out._iorder import IOrder
     from marketsim.gen._out._observable._observableiorder import ObservableIOrder
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import deref_opt
     ObservableIOrder.__init__(self)
     self.signedVolume = signedVolume if signedVolume is not None else deref_opt(_constant_Float(1.0))
     self.price = price if price is not None else deref_opt(_constant_Float(100.0))

 def __init__(self, base = None, power = None):
     from marketsim.gen._out._observable import Observablefloat
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     Observablefloat.__init__(self)
     self.base = base if base is not None else _constant_Float(1.0)
     
     self.power = power if power is not None else _constant_Float(1.0)
     
     rtti.check_fields(self)

 def __init__(self, x = None, y = None):
     from marketsim.gen._out._observable import Observablefloat
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     Observablefloat.__init__(self)
     self.x = x if x is not None else _constant_Float(1.0)
     
     self.y = y if y is not None else _constant_Float(1.0)
     
     rtti.check_fields(self)
     _Sub_Impl.__init__(self)

 def __init__(self, signedVolume = None, price = None):
     from marketsim.gen._out._iorder import IOrder
     from marketsim.gen._out._observable import ObservableIOrder
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     ObservableIOrder.__init__(self)
     self.signedVolume = signedVolume if signedVolume is not None else _constant_Float(1.0)
     
     self.price = price if price is not None else _constant_Float(100.0)
     
     rtti.check_fields(self)

 def __init__(self, x = None, y = None):
     from marketsim import _
     from marketsim import event
     from marketsim.gen._out._observable._observablefloat import Observablefloat
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import deref_opt
     Observablefloat.__init__(self)
     self.x = x if x is not None else deref_opt(_constant_Float(1.0))
     self.y = y if y is not None else deref_opt(_constant_Float(1.0))
     self.impl = self.getImpl()
     event.subscribe(self.impl, _(self).fire, self)

 def __init__(self, x = None, elsePart = None):
     from marketsim import _
     from marketsim import rtti
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import event
     from marketsim.gen._out._observable import Observablefloat
     Observablefloat.__init__(self)
     self.x = x if x is not None else _constant_Float(1.0)
     self.elsePart = elsePart if elsePart is not None else _constant_Float(1.0)
     rtti.check_fields(self)
     self.impl = self.getImpl()
     event.subscribe(self.impl, _(self).fire, self)

 def __init__(self, side = None, price = None, volume = None):
     from marketsim.gen._out._iorder import IOrder
     from marketsim import rtti
     from marketsim.gen._out._observable import ObservableIOrder
     from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     ObservableIOrder.__init__(self)
     self.side = side if side is not None else _side_Sell_()
     
     self.price = price if price is not None else _constant_Float(100.0)
     
     self.volume = volume if volume is not None else _constant_Float(1.0)
     
     rtti.check_fields(self)

 def __init__(self, cond = None, ifpart = None, elsepart = None):
     from marketsim.gen._out._observable import Observablefloat
     from marketsim.gen._out._true import true_ as _true_
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     Observablefloat.__init__(self)
     self.cond = cond if cond is not None else _true_()
     
     self.ifpart = ifpart if ifpart is not None else _constant_Float(1.0)
     
     self.elsepart = elsepart if elsepart is not None else _constant_Float(1.0)
     
     rtti.check_fields(self)
     _Condition_Impl.__init__(self)

 def __init__(self, x = None):
     from marketsim.gen._out._observable._observablefloat import Observablefloat
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import deref_opt
     Observablefloat.__init__(self)
     self.x = x if x is not None else deref_opt(_constant_Float(1.0))
     Negate_Impl.__init__(self)

 def __init__(self, expiry = None, proto = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim.gen._out.order._curried._sidevolume_limit import sidevolume_Limit_Float as _order__curried_sidevolume_Limit_Float
     from marketsim import rtti
     self.expiry = expiry if expiry is not None else _constant_Float(10.0)
     self.proto = proto if proto is not None else _order__curried_sidevolume_Limit_Float()
     rtti.check_fields(self)

 def __call__(self, price = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim.gen._out.order._limit import Limit
     price = price if price is not None else _constant_Float(100.0)
     side = self.side
     volume = self.volume
     return Limit(side, price, volume)

 def __init__(self, proto = None, lotSize = None):
     from marketsim.gen._out.order._curried._sidevolume_price_limit import sidevolume_price_Limit_ as _order__curried_sidevolume_price_Limit_
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     self.proto = proto if proto is not None else _order__curried_sidevolume_price_Limit_()
     self.lotSize = lotSize if lotSize is not None else _constant_Float(10.0)
     rtti.check_fields(self)

    def __init__(self, side=None, volume=None):
        from marketsim.gen._out.side._sell import Sell_ as _side_Sell_
        from marketsim import deref_opt
        from marketsim.gen._out._constant import constant_Float as _constant_Float

        self.side = side if side is not None else deref_opt(_side_Sell_())
        self.volume = volume if volume is not None else deref_opt(_constant_Float(1.0))

 def __init__(self, maxloss = None, proto = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim.gen._out.order._curried._sidevolume_price_limit import sidevolume_price_Limit_ as _order__curried_sidevolume_price_Limit_
     from marketsim import rtti
     self.maxloss = maxloss if maxloss is not None else _constant_Float(0.1)
     self.proto = proto if proto is not None else _order__curried_sidevolume_price_Limit_()
     rtti.check_fields(self)

 def __call__(self, signedVolume = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import deref_opt
     from marketsim.gen._out.order._limitsigned import LimitSigned
     signedVolume = signedVolume if signedVolume is not None else deref_opt(_constant_Float(1.0))
     price = self.price
     return LimitSigned(signedVolume, price)

 def __init__(self, f = None, base = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import rtti
     self.f = f if f is not None else _constant_Float(1.0)
     self.base = base if base is not None else 1.002
     rtti.check_fields(self)
     self.impl = self.getImpl()

 def __call__(self, signedVolume = None):
     from marketsim.gen._out._constant import constant_Float as _constant_Float
     from marketsim import deref_opt
     from marketsim.gen._out.order._marketsigned import MarketSigned
     signedVolume = signedVolume if signedVolume is not None else deref_opt(_constant_Float(1.0))
     
     return MarketSigned(signedVolume)