Add trade generation and price/volatility updates for strategies

Implemented `trade_from_delta_adjustment` to generate trades based on delta adjustments. Added methods to update underlying price, volatility, and expiration date across base and specific strategies. Adjusted test assertions to reflect updated calculations.

Author: joaquinbejar

src/strategies/base.rs

@@ -694,6 +694,75 @@ pub trait Strategies: Validable + Positionable + BreakEvenable {
     ) -> Result<(), StrategyError> {
         unimplemented!("Set expiration date is not implemented for this strategy")
     }
+
+    /// Updates the underlying price for the strategy.
+    ///
+    /// # Parameters
+    /// - `_price`: A reference to a `Positive` value representing the new underlying price to update.
+    ///
+    /// # Returns
+    /// - `Ok(())` if the operation succeeds.
+    /// - `Err(StrategyError)` if there is an error during the operation.
+    ///
+    /// # Notes
+    /// This function is currently unimplemented and will panic if called.
+    /// It serves as a placeholder for strategies where updating the underlying
+    /// price has not yet been implemented.
+    ///
+    /// # Panics
+    /// Always panics with the message "Update underlying price is not implemented for this strategy".
+    ///
+    fn update_underlying_price(&mut self, _price: &Positive) -> Result<(), StrategyError> {
+        unimplemented!("Update underlying price is not implemented for this strategy")
+    }
+
+    /// Updates the volatility for the strategy.
+    ///
+    /// # Parameters
+    /// - `_volatility`: A reference to a `Positive` value representing the new volatility to set.
+    ///
+    /// # Returns
+    /// - `Ok(())`: If the update operation succeeds (currently unimplemented).
+    /// - `Err(StrategyError)`: If there is an error during the update process (place-holder as functionality is not implemented).
+    ///
+    /// # Notes
+    /// This method is currently unimplemented, and calling it will result in the `unimplemented!` macro being triggered, which causes a panic.
+    /// This function is a stub and should be implemented to handle setting the volatility specific to the strategy.
+    ///
+    fn update_volatility(&mut self, _volatility: &Positive) -> Result<(), StrategyError> {
+        unimplemented!("Update volatility is not implemented for this strategy")
+    }
+
+    /// Updates the expiration date for the current strategy.
+    ///
+    /// This function is designed to be overridden or modified in specific strategy implementations.
+    /// As it stands, calling this function will result in a panic, as it is not implemented for the
+    /// current strategy by default.
+    ///
+    /// # Parameters
+    /// - `_expiration_date`: The new `ExpirationDate` to update the strategy with. This argument is
+    ///   currently unused in this default implementation.
+    ///
+    /// # Returns
+    /// This function returns a `Result`:
+    /// - `Ok(())` if the update is successful. However, as this method is unimplemented,
+    ///   the success branch is not reachable for the default implementation.
+    /// - `Err(StrategyError)` if an error occurs. In this implementation, it will not return an error
+    ///   but rather panic.
+    ///
+    /// # Errors
+    /// None are returned because the function panics with an unimplemented message in this base
+    /// implementation.
+    ///
+    /// # Panics
+    /// Always panics with the message `"Update expiration date is not implemented for this strategy"`.
+    ///
+    fn update_expiration_date(
+        &mut self,
+        _expiration_date: ExpirationDate,
+    ) -> Result<(), StrategyError> {
+        unimplemented!("Update expiration date is not implemented for this strategy")
+    }
 }
 
 /// Trait for strategies that can calculate and update break-even points.

src/strategies/delta_neutral/model.rs

@@ -43,6 +43,7 @@ use crate::error::{GreeksError, PositionError, StrategyError};
 use crate::greeks::Greeks;
 use crate::greeks::calculate_delta_neutral_sizes;
 use crate::model::types::{Action, OptionStyle};
+use crate::model::{Trade, TradeStatusAble};
 use crate::strategies::Strategies;
 use crate::strategies::base::Positionable;
 use crate::{Options, Positive, Side};
@@ -752,6 +753,104 @@ pub trait DeltaNeutrality: Greeks + Positionable + Strategies {
         }
         Ok(())
     }
+
+    /// Generates a `Trade` object based on the given delta adjustment action.
+    ///
+    /// # Parameters
+    /// - `_action`: An `Action` representing the delta adjustment based on which the trade will be formulated.
+    ///
+    /// # Returns
+    /// A `Trade` object derived from the delta adjustment logic.
+    ///
+    /// # Notes
+    /// - This function is currently unimplemented. Ensure to provide implementation logic
+    ///   that determines the `Trade` based on the `Action` delta adjustment.
+    /// - Replace the `unimplemented!()` macro with the actual implementation when ready.
+    ///
+    fn trade_from_delta_adjustment(
+        &mut self,
+        action: Action,
+    ) -> Result<Vec<Trade>, Box<dyn Error>> {
+        let adjustments = self.delta_adjustments()?;
+        let mut trades = Vec::new();
+
+        // Process a single BuyOptions or SellOptions adjustment
+        let mut process_single_adjustment =
+            |adj: &DeltaAdjustment| -> Result<Option<Trade>, Box<dyn Error>> {
+                match adj {
+                    DeltaAdjustment::BuyOptions {
+                        quantity,
+                        strike,
+                        option_style,
+                        side,
+                    } => {
+                        if quantity.is_zero() {
+                            return Ok(None);
+                        }
+                        let positions = self.get_position(option_style, side, strike)?;
+                        if let Some(position) = positions.first() {
+                            let mut position_clone = (*position).clone();
+                            position_clone.option.quantity = *quantity;
+                            Ok(Some(position_clone.open()))
+                        } else {
+                            Ok(None)
+                        }
+                    }
+                    DeltaAdjustment::SellOptions {
+                        quantity,
+                        strike,
+                        option_style,
+                        side,
+                    } => {
+                        if quantity.is_zero() {
+                            return Ok(None);
+                        }
+                        let positions = self.get_position(option_style, side, strike)?;
+                        if let Some(position) = positions.first() {
+                            let mut position_clone = (*position).clone();
+                            position_clone.option.quantity = *quantity;
+                            Ok(Some(position_clone.close()))
+                        } else {
+                            Ok(None)
+                        }
+                    }
+                    _ => Ok(None),
+                }
+            };
+
+        for adjustment in adjustments {
+            match (&action, adjustment) {
+                // For Buy action, only process BuyOptions adjustments
+                (Action::Buy, adj @ DeltaAdjustment::BuyOptions { .. }) => {
+                    if let Some(trade) = process_single_adjustment(&adj)? {
+                        trades.push(trade);
+                    }
+                }
+
+                // For Sell action, only process SellOptions adjustments
+                (Action::Sell, adj @ DeltaAdjustment::SellOptions { .. }) => {
+                    if let Some(trade) = process_single_adjustment(&adj)? {
+                        trades.push(trade);
+                    }
+                }
+
+                // For Other action, process both adjustments in SameSize
+                (Action::Other, DeltaAdjustment::SameSize(a, b)) => {
+                    if let Some(trade) = process_single_adjustment(&a)? {
+                        trades.push(trade);
+                    }
+                    if let Some(trade) = process_single_adjustment(&b)? {
+                        trades.push(trade);
+                    }
+                }
+
+                // Ignore other combinations
+                _ => {}
+            }
+        }
+
+        Ok(trades)
+    }
 }
 
 /// # DeltaNeutralResponse

src/strategies/strangle.rs

@@ -575,6 +575,51 @@ impl Strategies for ShortStrangle {
         self.short_put.option.expiration_date = expiration_date;
         Ok(())
     }
+
+    fn update_underlying_price(&mut self, price: &Positive) -> Result<(), StrategyError> {
+        self.short_call.option.underlying_price = *price;
+        self.short_put.option.underlying_price = *price;
+        self.short_call.premium = Positive(
+            self.short_call
+                .option
+                .calculate_price_black_scholes()?
+                .abs(),
+        );
+        self.short_put.premium =
+            Positive(self.short_put.option.calculate_price_black_scholes()?.abs());
+        Ok(())
+    }
+
+    fn update_volatility(&mut self, volatility: &Positive) -> Result<(), StrategyError> {
+        self.short_call.option.implied_volatility = *volatility;
+        self.short_put.option.implied_volatility = *volatility;
+        self.short_call.premium = Positive(
+            self.short_call
+                .option
+                .calculate_price_black_scholes()?
+                .abs(),
+        );
+        self.short_put.premium =
+            Positive(self.short_put.option.calculate_price_black_scholes()?.abs());
+        Ok(())
+    }
+
+    fn update_expiration_date(
+        &mut self,
+        expiration_date: ExpirationDate,
+    ) -> Result<(), StrategyError> {
+        self.short_call.option.expiration_date = expiration_date;
+        self.short_put.option.expiration_date = expiration_date;
+        self.short_call.premium = Positive(
+            self.short_call
+                .option
+                .calculate_price_black_scholes()?
+                .abs(),
+        );
+        self.short_put.premium =
+            Positive(self.short_put.option.calculate_price_black_scholes()?.abs());
+        Ok(())
+    }
 }
 
 impl Validable for ShortStrangle {
@@ -4857,7 +4902,7 @@ mod tests_long_strangle_pnl {
         // At the money, both options should have time value but no intrinsic value
         // Initial cost is 2 * (premium + fees) = 2 * (5.0 + 1.0) = 12.0
         assert_pos_relative_eq!(pnl.initial_costs, pos!(12.0), pos!(1e-6));
-        assert_decimal_eq!(pnl.unrealized.unwrap(), dec!(0.746072), dec!(1e-6));
+        assert_decimal_eq!(pnl.unrealized.unwrap(), dec!(0.748425), dec!(1e-6));
         assert_eq!(pnl.initial_income, pos!(0.0));
         // Unrealized loss should be less than full premium paid (time value remains)
         assert!(pnl.unrealized.unwrap() > dec!(-12.0));
@@ -5019,7 +5064,7 @@ mod tests_short_strangle_pnl {
         // Initial income is 2 * premium = 2 * 5.0 = 10.0
         assert_pos_relative_eq!(pnl.initial_costs, pos!(2.0), pos!(1e-6));
         assert_pos_relative_eq!(pnl.initial_income, pos!(10.0), pos!(1e-6));
-        assert_decimal_eq!(pnl.unrealized.unwrap(), dec!(-0.746072), dec!(1e-6));
+        assert_decimal_eq!(pnl.unrealized.unwrap(), dec!(-0.748425), dec!(1e-6));
         // Unrealized loss should be less than max potential loss
         assert!(pnl.unrealized.unwrap() > dec!(-100.0)); // Using a large number as max theoretical loss is unlimited
     }