ButterflyPositionT

abstract def getAllLegs()(implicit scriptContext: <error>): SequenceT[TradeLegT]

abstract def getInstrument: InstrumentT

abstract def getLeg: TradeLegT

abstract def getNetOpenLegs()(implicit scriptContext: <error>): SequenceT[TradeLegT]

abstract def getOrderComments: String

abstract def getUnderlyingInstrument: InstrumentT

abstract def isAlreadySettled(): Boolean

abstract def isClosed()(implicit scriptContext: <error>): Boolean

abstract def selectPosition(positionID: String): SequenceT[PositionT]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def NaN(implicit scriptContext: <error>): DoubleT

var _underlyingSecurity: SecurityT

final def addStrategy(implicit scriptExecContext: <error>): TradeStrategiesT

final def asInstanceOf[T0]: T0

final def availableBuyingPower(implicit scriptContext: <error>): Double

Calculate the available buying power

def averageEntryPrice(implicit scriptExecContext: <error>): NumberT

Calculate average entry price of the positions (Debits are negative, while credits are positive)

def averageEntryPriceToUnderlyingPriceRatio(implicit scriptExecContext: <error>): NumberT

Calculate the average entry price to underlying price ratio (Debits are negative, while credits are positive)

def averageImpliedVolatilityOfLegs(implicit scriptExecContext: <error>): NumberT

Calculate the average implied volatility of the legs of the position (10% = 10, 50% = 50, etc)

final def buyingPower(implicit scriptContext: <error>): Double

Calculate the available buying power

final def cashBalance(implicit scriptContext: <error>): Double

Calculate the cash balance

def clone(): AnyRef

def close(comments: String = "", fillInstantly: Boolean = false)(implicit scriptExecContext: <error>): <error>

final def costBasis(updatePricesIfNaNFillPrice: Boolean = false)(implicit scriptContext: <error>): StatsValueT

final def costBasis(implicit scriptContext: <error>): StatsValueT

Calculate the cost basis of the position

def createClosingOrder(comments: String = "")(implicit scriptExecContext: <error>): <error>

def daysElapsed(implicit scriptContext: <error>): NumberT

Days Elapsed Since Position Was First Opened

def daysToExpiration(implicit scriptContext: <error>): NumberT

Days To Expiration

def daysToLastTradeableDate(implicit scriptContext: <error>): NumberT

Num Days To Last Tradeable Date

def delta(implicit scriptExecContext: <error>): NumberT

Calculate the delta, which measures sensitivity to a change in the price of the underlying (Scaled by position size)

def deltaUnscaled(implicit scriptExecContext: <error>): NumberT

Calculate the delta, which measures sensitivity to a change in the price of the underlying (Not scaled by position size)

final def entryPriceToUnderlyingPriceRatio(implicit scriptContext: <error>): NumberT

Calculate the ratio of entry price to the underlying stock price (position entry price / underlying price)

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expirationDate(implicit scriptContext: <error>): Date

Expiration Date

def finalize(): Unit

final def gainLoss(implicit scriptContext: <error>): NumberT

Calculate the profit / loss

def gamma(implicit scriptExecContext: <error>): NumberT

Calculate the gamma, which measures the rate of change of Delta (Scaled by position size)

def gammaUnscaled(implicit scriptExecContext: <error>): NumberT

Calculate the gamma, which measures the rate of change of Delta (NOT scaled by position size)

final def getClass(): Class[_]

final def getNetOpenQuantity(leg: LegT)(implicit scriptContext: <error>): Double

def hasOpenContracts(position: PosT)(implicit scriptContext: <error>): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def marginRequirements(implicit scriptContext: <error>): StatsValueT

Calculate the margin requirements

final def marketValue(implicit scriptContext: <error>): StatsValueT

Calculate the market value

def marketValueAsPercentOfOverallPortfolio(implicit scriptContext: <error>): NumberT

Calculate the market value of the position as a percentage of the overall portfolio value (10% = 0.

final def marketValueExcludeInitialCashBalance(implicit scriptContext: <error>): StatsValueT

Calculate the market value excluding the initial cash balance

def marketValueNatural(implicit scriptContext: <error>): StatsValueT

Calculate the market value using natural prices of the position

final def marketValueNaturalExcludeInitialCashBalance(implicit scriptContext: <error>): StatsValueT

Calculate the market value using natural prices, excluding the initial cash balance

final def maxBreakEvenPoint(implicit scriptContext: <error>): NumberT

Maximum Break-Even Point At Expiration

final def maxReward(implicit scriptContext: <error>): StatsValueT

Calculate the maximum reward

final def maxRisk(implicit scriptContext: <error>): StatsValueT

Calculate the maximum risk.

final def minBreakEvenPoint(implicit scriptContext: <error>): NumberT

Minimum Break-Even Point At Expiration

final def minDistanceFromUnderlying(implicit scriptContext: <error>): DoubleT

Calculate the minimum absolute distance to the underlying instrument for the legs of the position

final def ne(arg0: AnyRef): Boolean

def netOpenUnderlyingInstrumentQuantity(implicit scriptExecContext: <error>): Double

Calculate the net open shares of the underlying instrument

def netOpenUnderlyingInstrumentUncoveredQuantity(implicit scriptExecContext: <error>): Double

* Calculate the net open shares of the underlying instrument that is NOT covered by short options

final def notify(): Unit

final def notifyAll(): Unit

final def numberOfContractsAssigned()(implicit scriptContext: <error>): NumberT

Number of contracts that have been assigned / exercise.

final def optionGreeks(implicit scriptContext: <error>): OptionGreeksT

Calculate the option greeks of the position

final def optionGreeksUnscaled(implicit scriptContext: <error>): OptionGreeksT

Calculate the option greeks of the position (NOT scaled based on position size)

final def positionEntryPrice(implicit scriptContext: <error>): NumberT

Calculate the entry price of the position (Debits are negative, while credits are positive)

final def positionNaturalPrice(implicit scriptContext: <error>): NumberT

Calculate the market price of the position using natural prices

final def positionPrice(implicit scriptContext: <error>): NumberT

Calculate the market price of the position (Debits are negative, while credits are positive)

final def positionPriceToUnderlyingPriceRatio(implicit scriptContext: <error>): NumberT

Calculate the ratio of position's price to the underlying stock price (position price / underlying price)

def returnOnCostBasis(implicit scriptContext: <error>): NumberT

Calculate the percentage return based on the cost basis of the position (10% = 0.

final def returnOnMargin(implicit scriptContext: <error>): NumberT

Calculate the percentage return based on the margin of the position (10% = 0.

final def returnOnMaxReward(implicit scriptContext: <error>): NumberT

Calculate the percentage return based on the max reward of the position (10% = 0.

final def returnOnMaxRisk(implicit scriptContext: <error>): NumberT

Calculate the percentage return based on the max risk of the position (10% = 0.

final def returnOnPortfolio(implicit scriptContext: <error>): ComparatorMathOperationsT

Calculate the cumulative percentage return on the initial portfolio value.

def rho(implicit scriptExecContext: <error>): NumberT

Calculate the rho, which measures the sensitivity to interest rates.

def rhoUnscaled(implicit scriptExecContext: <error>): NumberT

Calculate the rho, which measures the sensitivity to interest rates.

final def riskReward(implicit scriptContext: <error>): DoubleT

Calculate the risk / reward of the position (10% = 0.

final def selectHighestStrike(implicit scriptCtx: <error>): PosTT

Select the attributes for the highest strike leg of the butterfly.

final def selectLowestStrike(implicit scriptCtx: <error>): PosTT

Select the attributes for the lowest strike leg of the butterfly

final def selectMiddleStrike(implicit scriptCtx: <error>): PosTT

Select the attributes for the middle strike leg of the butterfly.

def selectPosT(positionID: String, targetStrategy: String = "", removeClosedLegs: Boolean = true)(implicit scriptContext: <error>): PosTT

def selectPosition(positionID: String, throwErrorIfNotFound: Boolean = true, targetStrategy: String = "", removeClosedLegs: Boolean = true)(implicit scriptContext: <error>): SequenceT[PositionT]

final def synchronized[T0](arg0: ⇒ T0): T0

def theoreticalMarketValue(daysToExpiration: Double, underlyingPrice: Double)(implicit scriptContext: <error>): NumberT

Calculate the theoretical market value of the position at a specific daysToExpiraion and underlyingPrice

def theta(implicit scriptExecContext: <error>): NumberT

Calculate the theta, which measures the sensitivity to the passage of time (Scaled by position size)

def thetaUnscaled(implicit scriptExecContext: <error>): NumberT

Calculate the theta, which measures the sensitivity to the passage of time (Not scaled by position size)

def toString(): String

final def underlyingInstrumentPrice(implicit scriptContext: <error>): NumberT

Get the price of the underlying instrument (Assumes all legs in the position have the same underlying instrument)

def vega(implicit scriptExecContext: <error>): NumberT

Calculate the vega, which measures the risk of gain or loss resulting from changes in volatility.

def vegaUnscaled(implicit scriptExecContext: <error>): NumberT

Calculate the vega, which measures the risk of gain or loss resulting from changes in volatility.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit