Struct CustomStrategy 

pub struct CustomStrategy {
    pub name: String,
    pub symbol: String,
    pub kind: StrategyType,
    pub description: String,
    pub break_even_points: Vec<Positive>,
    pub positions: Vec<Position>,
    pub underlying_price: Positive,
    /* private fields */
}

Represents a custom options trading strategy with user-defined positions and characteristics.

The CustomStrategy struct allows traders to create and analyze bespoke options strategies that don’t fit into standard predefined patterns. It contains information about the strategy’s positions, risk-reward profile, break-even points, and provides methods for profit-loss analysis.

This structure supports both analytical calculations and visualization of custom strategies, enabling traders to evaluate potential outcomes across different price points of the underlying asset.

Fields

name: String

The name of the custom strategy.

symbol: String

The ticker symbol of the underlying asset.

kind: StrategyType

The type of strategy, typically set to StrategyType::Custom.

description: String

A detailed description of the strategy, its purpose, and expected outcomes.

break_even_points: Vec<Positive>

The price points at which the strategy breaks even (neither profit nor loss).

positions: Vec<Position>

The collection of option positions that make up the strategy.

underlying_price: Positive

The current price of the underlying asset.

Implementations

impl CustomStrategy

pub fn new( name: String, symbol: String, description: String, underlying_price: Positive, positions: Vec<Position>, epsilon: Positive, max_iterations: u32, step_by: Positive, ) -> Result<Self, StrategyError>

Creates a new custom options trading strategy with the specified parameters.

This constructor initializes a CustomStrategy instance and performs several validation and calculation steps to ensure the strategy is valid and properly analyzed before being returned to the caller.

Parameters

• name - The name of the custom strategy
• symbol - The ticker symbol of the underlying asset
• description - A detailed description of the strategy’s purpose and characteristics
• underlying_price - The current price of the underlying asset
• positions - A collection of option positions that compose the strategy
• epsilon - Tolerance value used in numerical calculations for finding critical points
• max_iterations - Maximum number of iterations allowed in numerical algorithms
• step_by - Step size used in price interval calculations

Returns

A fully initialized CustomStrategy instance with calculated break-even points, maximum profit, and maximum loss information.

Errors

Returns StrategyError::OperationError when positions is empty, and propagates any error from update_break_even_points.

Trait Implementations

impl BasicAble for CustomStrategy

fn get_title(&self) -> String

Retrieves the title associated with the current instance of the strategy.

fn get_option_basic_type(&self) -> HashSet<OptionBasicType<'_>>

Retrieves a HashSet of OptionBasicType values associated with the current strategy.

fn get_implied_volatility(&self) -> HashMap<OptionBasicType<'_>, &Positive>

Retrieves the implied volatility for the current strategy.

fn get_quantity(&self) -> HashMap<OptionBasicType<'_>, &Positive>

Retrieves the quantity information associated with the strategy.

fn one_option(&self) -> &Options

Retrieves a shared reference to the strategy’s primary Options value.

fn one_option_mut(&mut self) -> &mut Options

Provides a mutable reference to the strategy’s primary Options value.

fn set_expiration_date( &mut self, expiration_date: ExpirationDate, ) -> Result<(), StrategyError>

Sets the expiration date for the strategy.

fn set_underlying_price( &mut self, price: &Positive, ) -> Result<(), StrategyError>

Sets the underlying price for this strategy.

fn set_implied_volatility( &mut self, volatility: &Positive, ) -> Result<(), StrategyError>

Updates the volatility for the strategy.

fn get_symbol(&self) -> &str

Retrieves the symbol associated with the current instance by delegating the call to the get_symbol method of the one_option object.

fn get_strike(&self) -> HashMap<OptionBasicType<'_>, &Positive>

Retrieves a mapping of option basic types to their associated positive strike values.

fn get_strikes(&self) -> Vec<&Positive>

Retrieves a vector of strike prices from the option types.

fn get_side(&self) -> HashMap<OptionBasicType<'_>, &Side>

Retrieves a HashMap that maps each OptionBasicType to its corresponding Side.

fn get_type(&self) -> &OptionType

Retrieves the type of the option.

fn get_style(&self) -> HashMap<OptionBasicType<'_>, &OptionStyle>

Retrieves a mapping of OptionBasicType to their corresponding OptionStyle.

fn get_expiration(&self) -> HashMap<OptionBasicType<'_>, &ExpirationDate>

Retrieves a map of option basic types to their corresponding expiration dates.

fn get_underlying_price(&self) -> &Positive

Retrieves the underlying price of the financial instrument (e.g., option).

fn get_risk_free_rate(&self) -> HashMap<OptionBasicType<'_>, &Decimal>

Retrieves the risk-free interest rate associated with a given set of options.

fn get_dividend_yield(&self) -> HashMap<OptionBasicType<'_>, &Positive>

Retrieves the dividend yield of a financial option.

impl BreakEvenable for CustomStrategy

fn get_break_even_points(&self) -> Result<&Vec<Positive>, StrategyError>

Retrieves the break-even points for the strategy.

fn update_break_even_points(&mut self) -> Result<(), StrategyError>

Updates the break-even points for the strategy.

impl Clone for CustomStrategy

fn clone(&self) -> CustomStrategy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ComposeSchema for CustomStrategy

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for CustomStrategy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DeltaNeutrality for CustomStrategy

fn delta_neutrality(&self) -> Result<DeltaInfo, GreeksError>

Calculates the net delta of the strategy and provides detailed information.

fn is_delta_neutral(&self) -> bool

Checks if the strategy is delta neutral within the specified threshold.

fn get_atm_strike(&self) -> Result<Positive, StrategyError>

get_atm_strike

fn generate_delta_adjustments( &self, net_delta: Decimal, option_delta_per_contract: Decimal, option: &Options, ) -> Result<DeltaAdjustment, GreeksError>

Generates delta adjustments based on the given net delta and option delta per contract.

fn delta_adjustments(&self) -> Result<Vec<DeltaAdjustment>, GreeksError>

Calculates required position adjustments to maintain delta neutrality

fn apply_delta_adjustments( &mut self, action: Option<Action>, ) -> Result<(), StrategyError>

Apply Delta Adjustments

fn apply_single_adjustment( &mut self, adjustment: &DeltaAdjustment, ) -> Result<(), StrategyError>

Apply Single Adjustment

fn adjust_option_position( &mut self, quantity: Decimal, strike: &Positive, option_type: &OptionStyle, side: &Side, ) -> Result<(), StrategyError>

Adjust Option Position

fn trade_from_delta_adjustment( &mut self, action: Action, ) -> Result<Vec<Trade>, StrategyError>

Generates a Trade object based on the given delta adjustment action.

fn portfolio_greeks(&self) -> Result<PortfolioGreeks, GreeksError>

Calculates portfolio-level Greeks for the strategy.

fn optimized_adjustment_plan( &self, config: AdjustmentConfig, target: AdjustmentTarget, ) -> Result<AdjustmentPlan, StrategyError>

Generates an optimized adjustment plan to achieve target Greeks.

fn optimized_adjustment_plan_with_chain( &self, chain: &OptionChain, config: AdjustmentConfig, target: AdjustmentTarget, ) -> Result<AdjustmentPlan, StrategyError>

Generates an optimized adjustment plan using an option chain for new legs.

fn meets_greek_targets( &self, target: &AdjustmentTarget, tolerance: Decimal, ) -> bool

Checks if the strategy meets the specified Greek targets.

fn delta_gap(&self, target_delta: Decimal) -> Result<Decimal, GreeksError>

Returns the delta gap from a target value.

impl<'de> Deserialize<'de> for CustomStrategy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Graph for CustomStrategy

fn graph_data(&self) -> GraphData

Return the raw data ready for plotting.

fn graph_config(&self) -> GraphConfig

Optional per‑object configuration overrides.

impl Greeks for CustomStrategy

fn get_options(&self) -> Result<Vec<&Options>, GreeksError>

Returns a vector of references to the option contracts for which Greeks will be calculated.

fn greeks(&self) -> Result<Greek, GreeksError>

Calculates and returns all Greeks as a single Greek struct.

fn delta(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate delta value for all options.

fn gamma(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate gamma value for all options.

fn theta(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate theta value for all options.

fn vega(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate vega value for all options.

fn rho(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate rho value for all options.

fn rho_d(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate rho_d value for all options.

fn alpha(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate alpha value for all options.

fn vanna(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate vanna value for all options.

fn vomma(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate vomma value for all options.

fn veta(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate veta value for all options.

fn charm(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate charm value for all options.

fn color(&self) -> Result<Decimal, GreeksError>

Calculates the aggregate color value for all options.

impl Optimizable for CustomStrategy

type Strategy = CustomStrategy

The type of strategy associated with this optimization.

fn find_optimal( &mut self, option_chain: &OptionChain, side: FindOptimalSide, criteria: OptimizationCriteria, )

Finds the optimal strategy based on the given criteria. The default implementation is a safe no-op: it emits a warning and leaves self unchanged. Specific strategies should override this method to provide their own optimization logic.

fn get_best_ratio(&mut self, option_chain: &OptionChain, side: FindOptimalSide)

Finds the best ratio-based strategy within the given OptionChain.

fn get_best_area(&mut self, option_chain: &OptionChain, side: FindOptimalSide)

Finds the best area-based strategy within the given OptionChain.

fn filter_combinations<'a>( &'a self, _option_chain: &'a OptionChain, _side: FindOptimalSide, ) -> impl Iterator<Item = OptionDataGroup<'a>>

Filters and generates combinations of options data from the given OptionChain.

fn is_valid_optimal_option( &self, option: &OptionData, side: &FindOptimalSide, ) -> bool

Checks if a long option is valid based on the given criteria.

fn are_valid_legs(&self, legs: &StrategyLegs<'_>) -> bool

Checks if the prices in the given StrategyLegs are valid. Assumes the strategy consists of one long call and one short call by default.

fn create_strategy( &self, _chain: &OptionChain, _legs: &StrategyLegs<'_>, ) -> Result<Self::Strategy, StrategyError>

Creates a new strategy from the given OptionChain and StrategyLegs.

impl PnLCalculator for CustomStrategy

fn calculate_pnl( &self, market_price: &Positive, expiration_date: ExpirationDate, implied_volatility: &Positive, ) -> Result<PnL, PricingError>

Calculates the current PnL based on market conditions.

fn calculate_pnl_at_expiration( &self, underlying_price: &Positive, ) -> Result<PnL, PricingError>

Calculates the PnL at the expiration of the instrument.

fn adjustments_pnl( &self, adjustment: &DeltaAdjustment, ) -> Result<PnL, PricingError>

Calculates the Profit and Loss (PnL) for a single delta adjustment applied to a trading strategy.

fn diff_position_pnl(&self, _position: &Position) -> Result<PnL, PricingError>

Calculates the profit and loss (PnL) for a given trading position.

impl Positionable for CustomStrategy

fn add_position(&mut self, position: &Position) -> Result<(), PositionError>

Adds a position to the strategy.

fn get_positions(&self) -> Result<Vec<&Position>, PositionError>

Retrieves all positions held by the strategy.

fn get_position( &mut self, option_style: &OptionStyle, side: &Side, strike: &Positive, ) -> Result<Vec<&mut Position>, PositionError>

Retrieves a specific position based on option style, side, and strike.

fn get_position_unique( &mut self, option_style: &OptionStyle, side: &Side, ) -> Result<&mut Position, PositionError>

Retrieves a unique position based on the given option style and side.

fn get_option_unique( &mut self, option_style: &OptionStyle, side: &Side, ) -> Result<&mut Options, PositionError>

Retrieves a unique option based on the given style and side.

fn modify_position(&mut self, position: &Position) -> Result<(), PositionError>

Modifies an existing position.

fn replace_position(&mut self, position: &Position) -> Result<(), PositionError>

Attempts to replace the current position with a new position.

fn valid_premium_for_shorts(&self, min_premium: &Positive) -> bool

Checks if all short positions have a net premium received that meets or exceeds a specified minimum.

impl ProbabilityAnalysis for CustomStrategy

fn get_profit_ranges(&self) -> Result<Vec<ProfitLossRange>, ProbabilityError>

Get the price ranges that would result in a profit

fn get_loss_ranges(&self) -> Result<Vec<ProfitLossRange>, ProbabilityError>

Get Profit/Loss Ranges

fn analyze_probabilities( &self, volatility_adj: Option<VolatilityAdjustment>, trend: Option<PriceTrend>, ) -> Result<StrategyProbabilityAnalysis, ProbabilityError>

Calculate probability analysis for a strategy

fn expected_value( &self, volatility_adj: Option<VolatilityAdjustment>, trend: Option<PriceTrend>, ) -> Result<Positive, ProbabilityError>

This function calculates the expected value of an option strategy based on an underlying price, volatility adjustments, and price trends.

fn probability_of_profit( &self, volatility_adj: Option<VolatilityAdjustment>, trend: Option<PriceTrend>, ) -> Result<Positive, ProbabilityError>

Calculate probability of profit

fn probability_of_loss( &self, volatility_adj: Option<VolatilityAdjustment>, trend: Option<PriceTrend>, ) -> Result<Positive, ProbabilityError>

Calculate probability of loss

fn calculate_extreme_probabilities( &self, volatility_adj: Option<VolatilityAdjustment>, trend: Option<PriceTrend>, ) -> Result<(Positive, Positive), ProbabilityError>

Calculate extreme probabilities (max profit and max loss)

impl Profit for CustomStrategy

fn calculate_profit_at(&self, price: &Positive) -> Result<Decimal, PricingError>

Calculates the profit at a specified price.

fn get_point_at_price( &self, _price: &Positive, ) -> Result<(Decimal, Decimal), PricingError>

Creates a chart point representation of the profit at the given price.

impl Serialize for CustomStrategy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Strategable for CustomStrategy

fn info(&self) -> Result<StrategyBasics, StrategyError>

Returns basic information about the strategy, such as its name, type, and description.

fn type_name(&self) -> StrategyType

Returns the type of the strategy.

fn name(&self) -> String

Returns the name of the strategy.

impl Strategies for CustomStrategy

fn get_volume(&mut self) -> Result<Positive, StrategyError>

Retrieves the current volume of the strategy as sum of quantities in their positions

fn get_max_profit(&self) -> Result<Positive, StrategyError>

Calculates the maximum possible profit for the strategy. The default implementation returns an error indicating that the operation is not supported.

fn get_max_loss(&self) -> Result<Positive, StrategyError>

Calculates the maximum possible loss for the strategy. The default implementation returns an error indicating that the operation is not supported.

fn get_profit_area(&self) -> Result<Decimal, StrategyError>

Calculates the profit area for the strategy. The default implementation returns an error indicating that the operation is not supported.

fn get_profit_ratio(&self) -> Result<Decimal, StrategyError>

Calculates the profit ratio for the strategy. The default implementation returns an error indicating that the operation is not supported.

fn get_best_range_to_show( &self, step: Positive, ) -> Result<Vec<Positive>, StrategyError>

Generates a vector of prices within the display range, using a specified step.

fn roll_in( &mut self, _position: &Position, ) -> Result<HashMap<Action, Trade>, StrategyError>

Attempts to execute the roll-in functionality for the strategy.

fn roll_out( &mut self, _position: &Position, ) -> Result<HashMap<Action, Trade>, StrategyError>

Executes the roll-out strategy for the provided position.

fn get_max_profit_mut(&mut self) -> Result<Positive, StrategyError>

Calculates the maximum possible profit for the strategy, potentially using an iterative approach. Defaults to calling max_profit.

fn get_max_loss_mut(&mut self) -> Result<Positive, StrategyError>

Calculates the maximum possible loss for the strategy, potentially using an iterative approach. Defaults to calling max_loss.

fn get_total_cost(&self) -> Result<Positive, PositionError>

Calculates the total cost of the strategy, which is the sum of the absolute cost of all positions.

fn get_net_cost(&self) -> Result<Decimal, PositionError>

Calculates the net cost of the strategy, which is the sum of the costs of all positions, considering premiums paid and received.

fn get_net_premium_received(&self) -> Result<Positive, StrategyError>

Calculates the net premium received for the strategy. This is the total premium received from short positions minus the total premium paid for long positions. If the result is negative, it returns zero.

fn get_fees(&self) -> Result<Positive, StrategyError>

Calculates the total fees for the strategy by summing the fees of all positions.

fn get_range_to_show(&self) -> Result<(Positive, Positive), StrategyError>

Determines the price range to display for the strategy’s profit/loss graph. This range is calculated based on the break-even points, the underlying price, and the maximum and minimum strike prices. The range is expanded by applying STRIKE_PRICE_LOWER_BOUND_MULTIPLIER and STRIKE_PRICE_UPPER_BOUND_MULTIPLIER to the minimum and maximum prices respectively.

fn get_max_min_strikes(&self) -> Result<(Positive, Positive), StrategyError>

Returns the minimum and maximum strike prices from the positions in the strategy. Considers underlying price when applicable, ensuring the returned range includes it.

fn get_range_of_profit(&self) -> Result<Positive, StrategyError>

Calculates the range of prices where the strategy is profitable, based on the break-even points.

impl StrategyConstructor for CustomStrategy

fn get_strategy(vec_options: &[Position]) -> Result<Self, StrategyError>

Attempts to construct a strategy from a vector of option positions.

impl ToSchema for CustomStrategy

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.

impl Validable for CustomStrategy

fn validate(&self) -> bool

Validates the strategy.