Merge branch 'master' into finstuff

Author: showmyth

DIRECTORY.md

@@ -106,8 +106,11 @@
   * Financial
     * [Present Value](https://github.com/TheAlgorithms/Rust/blob/master/src/financial/present_value.rs)
     * [Net Present Value](https://github.com/TheAlgorithms/Rust/blob/master/src/financial/npv.rs)
+    * [NPV Sensitivity](https://github.com/TheAlgorithms/Rust/blob/master/src/financial/npv_sensitivity.rs)
     * [Compound Interest](https://github.com/TheAlgorithms/Rust/blob/master/src/financial/compound_interest.rs)
     * [Payback Period](https://github.com/TheAlgorithms/Rust/blob/master/src/financial/payback.rs)
+    * [Finance Ratios](https://github.com/TheAlgorithms/Rust/blob/master/src/financial/finance_ratios.rs)
+    * [Treynor Ratio](https://github.com/TheAlgorithms/Rust/blob/master/src/financial/treynor_ratio.rs)
   * General
     * [Convex Hull](https://github.com/TheAlgorithms/Rust/blob/master/src/general/convex_hull.rs)
     * [Fisher Yates Shuffle](https://github.com/TheAlgorithms/Rust/blob/master/src/general/fisher_yates_shuffle.rs)

src/financial/finance_ratios.rs

@@ -0,0 +1,50 @@
+// Calculating simple ratios like Return on Investment (ROI), Debt to Equity, Gross Profit Margin
+// and Earnings per Sale (EPS)
+pub fn return_on_investment(gain: f64, cost: f64) -> f64 {
+    (gain - cost) / cost
+}
+
+pub fn debt_to_equity(debt: f64, equity: f64) -> f64 {
+    debt / equity
+}
+
+pub fn gross_profit_margin(revenue: f64, cost: f64) -> f64 {
+    (revenue - cost) / revenue
+}
+
+pub fn earnings_per_sale(net_income: f64, pref_dividend: f64, share_avg: f64) -> f64 {
+    (net_income - pref_dividend) / share_avg
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_return_on_investment() {
+        // let gain = 1200, cost = 1000 thus, ROI = (1200 - 1000)/1000 = 0.2
+        let result = return_on_investment(1200.0, 1000.0);
+        assert!((result - 0.2).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_debt_to_equity() {
+        // let debt = 300, equity = 150 thus, debt to equity ratio = 300/150 = 2
+        let result = debt_to_equity(300.0, 150.0);
+        assert!((result - 2.0).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_gross_profit_margin() {
+        // let revenue = 1000, cost = 800 thus, gross profit margin = (1000-800)/1000 = 0.2
+        let result = gross_profit_margin(1000.0, 800.0);
+        assert!((result - 0.2).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_earnings_per_sale() {
+        // let net_income = 350, pref_dividend = 50, share_avg = 25 this EPS = (350-50)/25 = 12
+        let result = earnings_per_sale(350.0, 50.0, 25.0);
+        assert!((result - 12.0).abs() < 0.001);
+    }
+}

src/financial/mod.rs

@@ -1,8 +1,18 @@
 mod compound_interest;
+mod finance_ratios;
 mod npv;
+mod npv_sensitivity;
 mod payback;
 mod present_value;
+mod treynor_ratio;
 pub use compound_interest::compound_interest;
 pub use npv::npv;
+pub use npv_sensitivity::npv_sensitivity;
 pub use payback::payback;
 pub use present_value::present_value;
+pub use treynor_ratio::treynor_ratio;
+
+pub use finance_ratios::debt_to_equity;
+pub use finance_ratios::earnings_per_sale;
+pub use finance_ratios::gross_profit_margin;
+pub use finance_ratios::return_on_investment;

src/financial/npv_sensitivity.rs

@@ -0,0 +1,43 @@
+/// Computes the Net Present Value (NPV) of a cash flow series
+/// at multiple discount rates to show sensitivity.
+///
+/// # Inputs:
+/// - `cash_flows`: A slice of cash flows, where each entry is a period value
+///   e.g., year 0 is initial investment, year 1+ are returns or costs
+/// - `discount_rates`: A slice of discount rates, e.g. `[0.05, 0.10, 0.20]`,
+///   where each rate is evaluated independently.
+///
+/// # Output:
+/// - Returns a vector of NPV values, each corresponding to a rate in `discount_rates`.
+///   For example, output is `[npv_rate1, npv_rate2, ...]`.
+
+pub fn npv_sensitivity(cash_flows: &[f64], discount_rates: &[f64]) -> Vec<f64> {
+    discount_rates
+        .iter()
+        .cloned()
+        .map(|rate| {
+            cash_flows
+                .iter()
+                .enumerate()
+                .map(|(t, &cf)| cf / (1.0 + rate).powi(t as i32))
+                .sum()
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_npv_sensitivity() {
+        let cashflows = [-1000.00, 400.00, 400.00, 400.00];
+        let rates = [0.05, 0.1, 0.2];
+        let expected = [89.30, -5.26, -157.41];
+        let out = npv_sensitivity(&cashflows, &rates);
+        assert_eq!(out.len(), 3);
+        // value check
+        for (o, e) in out.iter().zip(expected.iter()) {
+            assert!((o - e).abs() < 0.1);
+        }
+    }
+}

src/financial/treynor_ratio.rs

@@ -0,0 +1,35 @@
+/// Calculates the Treynor Ratio for a portfolio.
+///
+/// # Inputs
+/// - `portfolio_return`: Portfolio return
+/// - `risk_free_rate`: Risk-free rate
+/// - `beta`: Portfolio beta
+/// where Beta is a financial metric that measures the systematic risk of a security or portfolio compared to the overall market.
+///
+/// # Output
+/// - Returns excess return per unit of market risk
+pub fn treynor_ratio(portfolio_return: f64, risk_free_rate: f64, beta: f64) -> f64 {
+    if beta == 0.0 {
+        f64::NAN
+    } else {
+        (portfolio_return - risk_free_rate) / beta
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_treynor_ratio() {
+        // for portfolio_return = 0.10, risk_free_rate = 0.05, beta = 1.5
+        // expected result: (0.10 - 0.05) / 1.5 = 0.033333...
+        assert!((treynor_ratio(0.10, 0.05, 1.50) - 0.03333).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_treynor_ratio_empty_beta() {
+        // test for zero beta (undefined ratio)
+        assert!(treynor_ratio(0.10, 0.05, 0.00).is_nan());
+    }
+}