Adding and updating docs for feature selection option.

Author: celsisdurham

README.md

@@ -43,6 +43,47 @@ Whether you are backtesting, researching, or building production trading systems
 
 ---
 
+## Feature Selection
+
+This crate supports feature selection, allowing you to include only the parts you need:
+
+### Types of Features
+- **indicators**: Only include technical indicator calculations
+- **strategies**: Only include trading strategies
+- **all**: Include both indicators and strategies (default)
+
+### How to Choose Features in Cargo.toml
+
+You can enable features in your `Cargo.toml` like this:
+
+```toml
+[dependencies]
+ta-lib-in-rust = { version = "x.y.z", features = ["strategies"] } # Only strategies
+ta-lib-in-rust = { version = "x.y.z", features = ["indicators"] } # Only indicators
+ta-lib-in-rust = { version = "x.y.z", features = ["all"] }        # Everything (default)
+```
+
+If you omit the `features` key, the default is `all`.
+
+### Programmatic Feature Selection
+
+You can also select features at runtime using the `FeatureSelection` enum and `select_features` function:
+
+```rust
+use ta_lib_in_rust::{FeatureSelection, select_features};
+let mut df = ...; // your Polars DataFrame
+// To add only indicators:
+let result = select_features(&mut df, FeatureSelection::Indicators);
+// To run a strategy:
+let result = select_features(&mut df, FeatureSelection::Strategy { strategy_name: "daily_1", params: None });
+// To do both:
+let result = select_features(&mut df, FeatureSelection::All { strategy_name: "daily_1", params: None });
+```
+
+See the crate documentation for more details and examples.
+
+---
+
 ## Installation
 
 Add to your `Cargo.toml`:

examples/compare_minute_indicator_strategies.rs

@@ -2,8 +2,15 @@ use polars::prelude::*;
 use ta_lib_in_rust::strategy::minute::{
     multi_indicator_minute_1, multi_indicator_minute_2, multi_indicator_minute_3,
 };
+use ta_lib_in_rust::{FeatureSelection, select_features};
+use std::env;
 
 fn main() -> Result<(), PolarsError> {
+    // Parse CLI arguments for feature selection
+    let args: Vec<String> = env::args().collect();
+    let feature_mode = args.get(1).map(|s| s.as_str()).unwrap_or("all");
+    let strategy_name = args.get(2).map(|s| s.as_str()).unwrap_or("minute_1");
+
     println!("Loading minute OHLCV data...");
     let df = CsvReadOptions::default()
         .with_has_header(true)
@@ -15,7 +22,7 @@ fn main() -> Result<(), PolarsError> {
     println!("{}", df.head(Some(5)));
 
     // Create a DataFrame with lowercase column names expected by the indicators
-    let df = df
+    let mut df = df
         .lazy()
         .select([
             col("Symbol").alias("symbol"),
@@ -29,6 +36,15 @@ fn main() -> Result<(), PolarsError> {
         ])
         .collect()?;
 
+    // Feature selection logic
+    let selection = match feature_mode {
+        "indicators" => FeatureSelection::Indicators,
+        "strategy" => FeatureSelection::Strategy { strategy_name, params: None },
+        _ => FeatureSelection::All { strategy_name, params: None },
+    };
+    let result_df = select_features(&mut df, selection)?;
+    println!("\nResulting DataFrame ({feature_mode}):\n{result_df}");
+
     // Initialize strategies with default parameters
     let params1 = multi_indicator_minute_1::StrategyParams::default();
     let params2 = multi_indicator_minute_2::StrategyParams::default();

examples/compare_multi_indicator_strategies.rs

@@ -3,8 +3,15 @@ use ta_lib_in_rust::strategy::daily::multi_indicator_daily_1;
 use ta_lib_in_rust::strategy::daily::multi_indicator_daily_2;
 use ta_lib_in_rust::strategy::daily::multi_indicator_daily_3;
 use ta_lib_in_rust::strategy::daily::multi_indicator_daily_4;
+use ta_lib_in_rust::{FeatureSelection, select_features};
+use std::env;
 
 fn main() -> Result<(), PolarsError> {
+    // Parse CLI arguments for feature selection
+    let args: Vec<String> = env::args().collect();
+    let feature_mode = args.get(1).map(|s| s.as_str()).unwrap_or("all");
+    let strategy_name = args.get(2).map(|s| s.as_str()).unwrap_or("daily_1");
+
     // Define the tickers to analyze
     let tickers = vec!["AAPL", "GOOGL", "MSFT"];
 
@@ -29,7 +36,7 @@ fn main() -> Result<(), PolarsError> {
         println!("==============================================================");
 
         // Load ticker's daily OHLCV data
-        let file_path = format!("examples/{}_daily_ohlcv.csv", ticker);
+        let file_path = format!("examples/csv/{}_daily_ohlcv.csv", ticker);
 
         // Read CSV file with Polars using CsvReadOptions
         let df = CsvReadOptions::default()
@@ -45,7 +52,7 @@ fn main() -> Result<(), PolarsError> {
         }
 
         // Create a new DataFrame with renamed columns and proper types
-        let df = df
+        let mut df = df
             .lazy()
             .select([
                 col("Open").alias("open"),
@@ -56,6 +63,15 @@ fn main() -> Result<(), PolarsError> {
             ])
             .collect()?;
 
+        // Feature selection logic
+        let selection = match feature_mode {
+            "indicators" => FeatureSelection::Indicators,
+            "strategy" => FeatureSelection::Strategy { strategy_name, params: None },
+            _ => FeatureSelection::All { strategy_name, params: None },
+        };
+        let result_df = select_features(&mut df, selection)?;
+        println!("\nResulting DataFrame for {ticker} ({feature_mode}):\n{result_df}");
+
         println!("--------------------------------------------------------------");
         println!(
             "COMPARATIVE ANALYSIS OF MULTI-INDICATOR TRADING STRATEGIES FOR {}",

src/lib.rs

@@ -264,11 +264,70 @@ pub mod util;
 pub use indicators::*;
 pub use strategy::*;
 
+use polars::prelude::Series;
+use polars::prelude::NamedFrom;
+
 // This is a placeholder function - should be removed before final release
 pub fn add(left: u64, right: u64) -> u64 {
     left + right
 }
 
+/// Enum for selecting which features to compute or expose
+pub enum FeatureSelection<'a> {
+    Indicators,
+    Strategy {
+        /// Name of the strategy module (e.g., "daily_1", "minute_2", etc.)
+        strategy_name: &'a str,
+        /// Optional parameters for the strategy (if needed)
+        params: Option<Box<dyn std::any::Any>>,
+    },
+    All {
+        /// Name of the strategy module
+        strategy_name: &'a str,
+        /// Optional parameters for the strategy
+        params: Option<Box<dyn std::any::Any>>,
+    },
+}
+
+/// Central function to select features (indicators, strategy, or all)
+pub fn select_features(
+    df: &mut polars::prelude::DataFrame,
+    selection: FeatureSelection,
+) -> polars::prelude::PolarsResult<polars::prelude::DataFrame> {
+    match selection {
+        FeatureSelection::Indicators => {
+            indicators::add_technical_indicators(df)
+        }
+        FeatureSelection::Strategy { strategy_name, params } => {
+            // Example: match on strategy_name and call the appropriate strategy
+            match strategy_name {
+                "daily_1" => {
+                    use crate::strategy::daily::multi_indicator_daily_1;
+                    let params = params
+                        .and_then(|p| p.downcast::<multi_indicator_daily_1::StrategyParams>().ok())
+                        .map(|b| *b)
+                        .unwrap_or_else(multi_indicator_daily_1::StrategyParams::default);
+                    let signals = multi_indicator_daily_1::run_strategy(df, &params)
+                        .map_err(|e| polars::prelude::PolarsError::ComputeError(format!("Strategy error: {e}").into()))?;
+                    // Return a DataFrame with signals (user can extract more as needed)
+                    let mut result = df.clone();
+                    result.with_column(Series::new("buy_signals".into(), &signals.buy_signals[..]))?;
+                    result.with_column(Series::new("sell_signals".into(), &signals.sell_signals[..]))?;
+                    Ok(result)
+                }
+                // Add more strategies as needed
+                _ => Err(polars::prelude::PolarsError::ComputeError("Unknown strategy name".into())),
+            }
+        }
+        FeatureSelection::All { strategy_name, params } => {
+            // Add indicators first
+            let mut df_with_ind = indicators::add_technical_indicators(df)?;
+            // Then run strategy
+            select_features(&mut df_with_ind, FeatureSelection::Strategy { strategy_name, params })
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;