diff --git a/CMakeLists.txt b/CMakeLists.txt
index cee0c24..5f44252 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -59,6 +59,11 @@ file(GLOB SOURCES "src/cpp/*/*.cpp")
 add_library(finmath_library SHARED ${SOURCES}
     "src/cpp/InterestAndAnnuities/simple_interest.cpp"
     "include/finmath/InterestAndAnnuities/simple_interest.h"
+    "include/finmath/InterestAndAnnuities/discount_factor.h"
+    "include/finmath/InterestAndAnnuities/present_future_value.h"
+    "include/finmath/InterestAndAnnuities/annuity.h"
+    "include/finmath/InterestAndAnnuities/cash_flow.h"
+    "include/finmath/FixedIncome/bond_pricing.h"
     "include/finmath/OptionPricing/options_pricing.h"
     "include/finmath/OptionPricing/options_pricing_types.h"
     "include/finmath/TimeSeries/rolling_volatility.h"
@@ -104,6 +109,15 @@ endmacro()
 add_cpp_test_labeled(CompoundInterestTest test/InterestAndAnnuities/compound_interest_test.cpp "InterestAndAnnuities;Unit")
 add_cpp_test_labeled(BlackScholesTest test/OptionPricing/black_scholes_test.cpp "OptionPricing;Unit")
 add_cpp_test_labeled(BinomialOptionPricingTest test/OptionPricing/binomial_option_pricing_test.cpp "OptionPricing;Unit")
+add_cpp_test_labeled(RSITest test/TimeSeries/rsi_test.cpp "TimeSeries;Unit")
+add_cpp_test_labeled(RollingStdDevTest test/TimeSeries/rolling_std_dev_test.cpp "TimeSeries;Unit")
+add_cpp_test_labeled(BellmanArbitrageTest test/GraphAlgos/bellman_arbitrage_test.cpp "GraphAlgos;Unit")
+add_cpp_test_labeled(BondPricingTest test/FixedIncome/bond_pricing_test.cpp "FixedIncome;Unit")
+add_cpp_test_labeled(AnnuityTest test/InterestAndAnnuities/annuity_test.cpp "InterestAndAnnuities;Unit")
+add_cpp_test_labeled(CashFlowTest test/InterestAndAnnuities/cash_flow_test.cpp "InterestAndAnnuities;Unit")
+add_cpp_test_labeled(DiscountFactorTest test/InterestAndAnnuities/discount_factor_test.cpp "InterestAndAnnuities;Unit")
+add_cpp_test_labeled(PresentFutureValueTest test/InterestAndAnnuities/present_future_value_test.cpp "InterestAndAnnuities;Unit")
+
 # add_cpp_test_labeled(RSITest test/TimeSeries/rsi_test.cpp "TimeSeries;Unit")
 # add_cpp_test_labeled(RollingStdDevTest test/TimeSeries/rolling_std_dev_test.cpp "TimeSeries;Unit")
 # add_cpp_test_labeled(BellmanArbitrageTest test/GraphAlgos/bellman_arbitrage_test.cpp "GraphAlgos;Unit")
diff --git a/include/finmath/FixedIncome/bond_pricing.h b/include/finmath/FixedIncome/bond_pricing.h
new file mode 100644
index 0000000..6080fba
--- /dev/null
+++ b/include/finmath/FixedIncome/bond_pricing.h
@@ -0,0 +1,75 @@
+#ifndef BOND_PRICING_H
+#define BOND_PRICING_H
+
+#include <cmath>
+#include <stdexcept>
+
+/**
+ * Bond price (coupon bond)
+ * Calculates the theoretical price of a bond
+ *
+ * @param face_value Face value (par value) of the bond
+ * @param coupon_rate Annual coupon rate (e.g., 0.05 for 5%)
+ * @param yield_to_maturity Yield to maturity (discount rate)
+ * @param periods Number of coupon payment periods per year
+ * @param time_to_maturity Time to maturity in years
+ * @return Bond price
+ *
+ * Formula: Price = sum(Coupon / (1+r)^i) + Face / (1+r)^n
+ *
+ * Example:
+ *   10-year bond, $1000 face, 5% coupon, paid semi-annually, 4% YTM
+ *   Coupon per period = $1000 * 0.05 / 2 = $25
+ *   Number of periods = 10 * 2 = 20
+ *   Rate per period = 0.04 / 2 = 0.02
+ */
+double bond_price(
+    double face_value,
+    double coupon_rate,
+    double yield_to_maturity,
+    int periods,
+    double time_to_maturity
+);
+
+/**
+ * Bond yield (simplified, iterative)
+ * Finds YTM given bond price
+ * Uses Newton-Raphson method
+ *
+ * @param face_value Face value of the bond
+ * @param coupon_rate Annual coupon rate
+ * @param price Current market price of the bond
+ * @param periods Number of coupon payment periods per year
+ * @param time_to_maturity Time to maturity in years
+ * @return Yield to maturity
+ */
+double bond_yield(
+    double face_value,
+    double coupon_rate,
+    double price,
+    int periods,
+    double time_to_maturity
+);
+
+/**
+ * Duration (Macaulay)
+ * Measures interest rate sensitivity
+ *
+ * @param face_value Face value of the bond
+ * @param coupon_rate Annual coupon rate
+ * @param yield_to_maturity Yield to maturity
+ * @param periods Number of coupon payment periods per year
+ * @param time_to_maturity Time to maturity in years
+ * @return Macaulay duration in years
+ *
+ * Formula: Duration = sum(t * PV(CF_t)) / Price
+ */
+double bond_duration(
+    double face_value,
+    double coupon_rate,
+    double yield_to_maturity,
+    int periods,
+    double time_to_maturity
+);
+
+#endif // BOND_PRICING_H
diff --git a/include/finmath/InterestAndAnnuities/annuity.h b/include/finmath/InterestAndAnnuities/annuity.h
new file mode 100644
index 0000000..b75b0c2
--- /dev/null
+++ b/include/finmath/InterestAndAnnuities/annuity.h
@@ -0,0 +1,61 @@
+#ifndef ANNUITY_H
+#define ANNUITY_H
+
+#include <cmath>
+#include <stdexcept>
+
+/**
+ * Present value of ordinary annuity
+ * Payments are made at the END of each period
+ *
+ * @param payment Payment amount per period
+ * @param rate Interest rate per period (not annualized if periods are not annual)
+ * @param periods Number of payment periods
+ * @return Present value of the annuity
+ *
+ * Formula: PV = P * [1 - (1+r)^(-n)] / r
+ *
+ * Edge cases:
+ * - If rate == 0: return payment * periods
+ * - If periods == 0: return 0
+ */
+double annuity_present_value(double payment, double rate, int periods);
+
+/**
+ * Future value of ordinary annuity
+ *
+ * @param payment Payment amount per period
+ * @param rate Interest rate per period
+ * @param periods Number of payment periods
+ * @return Future value of the annuity
+ *
+ * Formula: FV = P * [(1+r)^n - 1] / r
+ */
+double annuity_future_value(double payment, double rate, int periods);
+
+/**
+ * Present value of annuity due
+ * Payments are made at the BEGINNING of each period
+ *
+ * @param payment Payment amount per period
+ * @param rate Interest rate per period
+ * @param periods Number of payment periods
+ * @return Present value of annuity due
+ *
+ * Formula: PV = P * [1 - (1+r)^(-n)] / r * (1 + r)
+ */
+double annuity_due_present_value(double payment, double rate, int periods);
+
+/**
+ * Future value of annuity due
+ *
+ * @param payment Payment amount per period
+ * @param rate Interest rate per period
+ * @param periods Number of payment periods
+ * @return Future value of annuity due
+ *
+ * Formula: FV = P * [(1+r)^n - 1] / r * (1 + r)
+ */
+double annuity_due_future_value(double payment, double rate, int periods);
+
+#endif // ANNUITY_H
diff --git a/include/finmath/InterestAndAnnuities/cash_flow.h b/include/finmath/InterestAndAnnuities/cash_flow.h
new file mode 100644
index 0000000..8f29c56
--- /dev/null
+++ b/include/finmath/InterestAndAnnuities/cash_flow.h
@@ -0,0 +1,75 @@
+#ifndef CASH_FLOW_H
+#define CASH_FLOW_H
+
+#include <cmath>
+#include <stdexcept>
+#include <vector>
+
+
+/**
+ * Net Present Value
+ * Calculates the present value of all cash flows
+ *
+ * @param cash_flows Vector of cash flows (negative = outflow, positive = inflow)
+ * @param rate Discount rate (e.g., 0.10 for 10%)
+ * @param initial_investment Optional initial investment (default: 0.0)
+ * @return Net present value
+ *
+ * Formula: NPV = sum(CF_i / (1+r)^i) - Initial Investment
+ *
+ * Example:
+ *   cash_flows = [-1000, 100, 200, 300, 400]
+ *   rate = 0.10
+ *   NPV = -1000 + 100/(1.1) + 200/(1.1)^2 + 300/(1.1)^3 + 400/(1.1)^4
+ */
+double net_present_value(
+    const std::vector<double>& cash_flows,
+    double rate,
+    double initial_investment = 0.0
+);
+
+/**
+ * Internal Rate of Return
+ * Finds the discount rate that makes NPV = 0
+ * Uses Newton-Raphson iterative method
+ *
+ * @param cash_flows Vector of cash flows
+ * @param initial_guess Starting guess for IRR (default: 0.1 = 10%)
+ * @param max_iterations Maximum iterations for convergence (default: 100)
+ * @param tolerance Convergence tolerance (default: 1e-6)
+ * @return Internal rate of return
+ *
+ * Algorithm:
+ * 1. Start with initial guess
+ * 2. Calculate NPV and dNPV/dr at current guess
+ * 3. Update: r_new = r_old - NPV / dNPV/dr
+ * 4. Repeat until |NPV| < tolerance
+ *
+ * @throws std::runtime_error if convergence fails
+ */
+double internal_rate_of_return(
+    const std::vector<double>& cash_flows,
+    double initial_guess = 0.1,
+    int max_iterations = 100,
+    double tolerance = 1e-6
+);
+
+/**
+ * Payback period
+ * Returns the number of periods until cumulative cash flows exceed initial investment
+ *
+ * @param cash_flows Vector of cash flows (first element is typically initial investment)
+ * @param initial_investment Initial investment amount
+ * @return Number of periods until payback (returns -1 if never pays back)
+ *
+ * Example:
+ *   cash_flows = [100, 200, 300, 400]
+ *   initial_investment = 500
+ *   Cumulative: 100, 300, 600 (payback at period 3)
+ */
+int payback_period(
+    const std::vector<double>& cash_flows,
+    double initial_investment
+);
+
+#endif // CASH_FLOW_H
diff --git a/include/finmath/InterestAndAnnuities/discount_factor.h b/include/finmath/InterestAndAnnuities/discount_factor.h
new file mode 100644
index 0000000..676e2a0
--- /dev/null
+++ b/include/finmath/InterestAndAnnuities/discount_factor.h
@@ -0,0 +1,50 @@
+#ifndef DISCOUNT_FACTOR_H
+#define DISCOUNT_FACTOR_H
+
+#include <cmath>
+#include <stdexcept>
+
+
+/**
+ * Discrete compounding discount factor
+ * Converts a future value to present value using discrete compounding
+ *
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Discount factor (0 < DF <= 1)
+ *
+ * Formula: DF = 1 / (1 + r)^t
+ *
+ * @throws std::invalid_argument if rate < 0 or time < 0
+ */
+double discount_factor(double rate, double time);
+
+/**
+ * Continuous compounding discount factor
+ * Uses exponential compounding for continuous interest
+ *
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Discount factor (0 < DF <= 1)
+ *
+ * Formula: DF = e^(-r*t)
+ *
+ * @throws std::invalid_argument if rate < 0 or time < 0
+ */
+double discount_factor_continuous(double rate, double time);
+
+/**
+ * Future value factor
+ * Converts a present value to future value
+ *
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Future value factor (FVF >= 1)
+ *
+ * Formula: FVF = (1 + r)^t
+ *
+ * @throws std::invalid_argument if rate < 0 or time < 0
+ */
+double future_value_factor(double rate, double time);
+
+#endif // DISCOUNT_FACTOR_H
diff --git a/include/finmath/InterestAndAnnuities/present_future_value.h b/include/finmath/InterestAndAnnuities/present_future_value.h
new file mode 100644
index 0000000..2b07676
--- /dev/null
+++ b/include/finmath/InterestAndAnnuities/present_future_value.h
@@ -0,0 +1,59 @@
+#ifndef PRESENT_FUTURE_VALUE_H
+#define PRESENT_FUTURE_VALUE_H
+
+#include <cmath>
+#include <stdexcept>
+
+
+/**
+ * Present value with discrete compounding
+ * Calculates what a future amount is worth today
+ *
+ * @param future_value Amount to be received in the future
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years until the future value is received
+ * @return Present value of the future amount
+ *
+ * Formula: PV = FV / (1 + r)^t
+ */
+double present_value(double future_value, double rate, double time);
+
+/**
+ * Future value with discrete compounding
+ * Calculates what a current amount will be worth in the future
+ *
+ * @param present_value Current amount
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Future value of the present amount
+ *
+ * Formula: FV = PV * (1 + r)^t
+ */
+double future_value(double present_value, double rate, double time);
+
+/**
+ * Present value with continuous compounding
+ * Uses exponential compounding
+ *
+ * @param future_value Amount to be received in the future
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Present value with continuous compounding
+ *
+ * Formula: PV = FV * e^(-r*t)
+ */
+double present_value_continuous(double future_value, double rate, double time);
+
+/**
+ * Future value with continuous compounding
+ *
+ * @param present_value Current amount
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Future value with continuous compounding
+ *
+ * Formula: FV = PV * e^(r*t)
+ */
+double future_value_continuous(double present_value, double rate, double time);
+
+#endif // PRESENT_FUTURE_VALUE_H
diff --git a/src/cpp/FixedIncome/bond_pricing.cpp b/src/cpp/FixedIncome/bond_pricing.cpp
new file mode 100644
index 0000000..2777ed1
--- /dev/null
+++ b/src/cpp/FixedIncome/bond_pricing.cpp
@@ -0,0 +1,145 @@
+#include "finmath/FixedIncome/bond_pricing.h"
+
+/**
+ * Bond price (coupon bond)
+ * Calculates the theoretical price of a bond
+ *
+ * @param face_value Face value (par value) of the bond
+ * @param coupon_rate Annual coupon rate (e.g., 0.05 for 5%)
+ * @param yield_to_maturity Yield to maturity (discount rate)
+ * @param periods Number of coupon payment periods per year
+ * @param time_to_maturity Time to maturity in years
+ * @return Bond price
+ *
+ * Formula: Price = sum(Coupon / (1+r)^i) + Face / (1+r)^n
+ *
+ * Example:
+ *   10-year bond, $1000 face, 5% coupon, paid semi-annually, 4% YTM
+ *   Coupon per period = $1000 * 0.05 / 2 = $25
+ *   Number of periods = 10 * 2 = 20
+ *   Rate per period = 0.04 / 2 = 0.02
+ */
+
+double bond_price(
+    double face_value,
+    double coupon_rate,
+    double yield_to_maturity,
+    int periods,
+    double time_to_maturity
+) {
+    double coupon = face_value * coupon_rate / periods; // coupon per period
+    double r = yield_to_maturity / periods; // rate per period
+    int n = static_cast<int>(time_to_maturity * periods); // number of periods
+    
+    double pv_coupons = 0.0;
+    for (int i = 1; i <= n; ++i) {
+        pv_coupons += coupon / std::pow(1.0 + r, i);
+    }
+
+    double pv_face = face_value / std::pow(1.0 + r, n);
+
+    return pv_coupons + pv_face;
+}
+
+/**
+ * Bond yield (simplified, iterative)
+ * Finds YTM given bond price
+ * Uses Newton-Raphson method
+ *
+ * @param face_value Face value of the bond
+ * @param coupon_rate Annual coupon rate
+ * @param price Current market price of the bond
+ * @param periods Number of coupon payment periods per year
+ * @param time_to_maturity Time to maturity in years
+ * @return Yield to maturity
+ */
+double bond_yield(
+    double face_value,
+    double coupon_rate,
+    double price,
+    int periods,
+    double time_to_maturity
+) {
+    double r = coupon_rate / periods; // initial guess: coupon rate per period
+    int    n = static_cast<int>(time_to_maturity * periods);
+    double coupon = face_value * coupon_rate / periods;
+
+    constexpr int max_iterations = 100;
+    constexpr double tolerance = 1e12;
+
+    for (int iter = 0; iter < max_iterations; iter++) {
+        // f(r)  = bond_price(r) - market_price  →  find root
+        double f  = 0.0;
+        double df = 0.0;
+
+        for (int i = 1; i <= n; i++) {
+            double discount = std::pow(1.0 + r, i);
+            f  +=  coupon / discount;
+            df += -i * coupon / (discount * (1.0 + r));
+        }
+        double face_discount = std::pow(1.0 + r, n);
+        f  +=  face_value / face_discount;
+        df += -n * face_value / (face_discount * (1.0 + r));
+
+        f -= price; // offset by market price
+
+        if (std::abs(f) < tolerance) {
+            return r * periods; // convert per-period rate → annual YTM
+        }
+
+        if (std::abs(df) < 1e-12)
+            throw std::runtime_error("bond_yield: derivative near zero");
+
+        r -= f / df;
+
+        if (r <= -1.0) r = -0.999; // guard against negative base in pow()
+    }
+
+    throw std::runtime_error("bond_yield: failed to converge");
+}
+
+/**
+ * Duration (Macaulay)
+ * Measures interest rate sensitivity
+ *
+ * @param face_value Face value of the bond
+ * @param coupon_rate Annual coupon rate
+ * @param yield_to_maturity Yield to maturity
+ * @param periods Number of coupon payment periods per year
+ * @param time_to_maturity Time to maturity in years
+ * @return Macaulay duration in years
+ *
+ * Formula: Duration = sum(t * PV(CF_t)) / Price
+ */
+double bond_duration(
+    double face_value,
+    double coupon_rate,
+    double yield_to_maturity,
+    int periods,
+    double time_to_maturity
+) {
+    double coupon = face_value * coupon_rate / periods;
+    double r      = yield_to_maturity / periods;
+    int    n      = static_cast<int>(time_to_maturity * periods);
+
+    double weighted_pv = 0.0;
+    double total_pv    = 0.0;
+
+    for (int i = 1; i <= n; i++) {
+        double pv   = coupon / std::pow(1.0 + r, i);
+        double t    = static_cast<double>(i) / periods; // time in years
+        weighted_pv += t * pv;
+        total_pv    += pv;
+    }
+
+    // face value at maturity
+    double pv_face = face_value / std::pow(1.0 + r, n);
+    weighted_pv   += time_to_maturity * pv_face;
+    total_pv      += pv_face;
+
+    if (total_pv < 1e-12)
+        throw std::runtime_error("bond_duration: price is zero");
+
+    return weighted_pv / total_pv; // Macaulay duration in years
+}
+
diff --git a/src/cpp/InterestAndAnnuities/annuity.cpp b/src/cpp/InterestAndAnnuities/annuity.cpp
new file mode 100644
index 0000000..b48b705
--- /dev/null
+++ b/src/cpp/InterestAndAnnuities/annuity.cpp
@@ -0,0 +1,108 @@
+#include "finmath/InterestAndAnnuities/annuity.h"
+
+
+/**
+ * Present value of ordinary annuity
+ * Payments are made at the END of each period
+ *
+ * @param payment Payment amount per period
+ * @param rate Interest rate per period (not annualized if periods are not annual)
+ * @param periods Number of payment periods
+ * @return Present value of the annuity
+ *
+ * Formula: PV = P * [1 - (1+r)^(-n)] / r
+ *
+ * Edge cases:
+ * - If rate == 0: return payment * periods
+ * - If periods == 0: return 0
+ */
+
+double annuity_present_value(double payment, double rate, int periods) {
+    if (rate < 0.0) {
+        throw std::invalid_argument("rate must be non-negative");
+    }
+    if (periods < 0.0) {
+        throw std::invalid_argument("periods must be non-negative");
+    }
+    if (rate == 0.0) {
+        return payment * periods;
+    }
+    if (periods == 0.0) {
+        return 0.0;
+    }
+    return payment * (1 - std::pow(1.0 + rate, -periods)) / rate;
+}
+
+/**
+ * Future value of ordinary annuity
+ *
+ * @param payment Payment amount per period
+ * @param rate Interest rate per period
+ * @param periods Number of payment periods
+ * @return Future value of the annuity
+ *
+ * Formula: FV = P * [(1+r)^n - 1] / r
+ */
+
+double annuity_future_value(double payment, double rate, int periods) {
+    if (rate < 0.0) {
+        throw std::invalid_argument("rate must be non-negative");
+    }
+    if (periods < 0.0) {
+        throw std::invalid_argument("periods must be non-negative");
+    }
+    if (rate == 0.0) {
+        return payment * periods;
+    }
+
+    return payment * (std::pow(1.0 + rate, periods) - 1) / rate;
+}
+
+/**
+ * Present value of annuity due
+ * Payments are made at the BEGINNING of each period
+ *
+ * @param payment Payment amount per period
+ * @param rate Interest rate per period
+ * @param periods Number of payment periods
+ * @return Present value of annuity due
+ *
+ * Formula: PV = P * [1 - (1+r)^(-n)] / r * (1 + r)
+ */
+
+double annuity_due_present_value(double payment, double rate, int periods) {
+    if (rate < 0.0) {
+        throw std::invalid_argument("rate must be non-negative");
+    }
+    if (periods < 0.0) {
+        throw std::invalid_argument("periods must be non-negative");
+    }
+
+    return payment * (1 - std::pow(1.0 + rate, -periods)) / rate * (1.0 + rate);
+}
+
+/**
+ * Future value of annuity due
+ *
+ * @param payment Payment amount per period
+ * @param rate Interest rate per period
+ * @param periods Number of payment periods
+ * @return Future value of annuity due
+ *
+ * Formula: FV = P * [(1+r)^n - 1] / r * (1 + r)
+ */
+
+double annuity_due_future_value(double payment, double rate, int periods) {
+    if (rate < 0.0) {
+        throw std::invalid_argument("rate must be non-negative");
+    }
+    if (periods < 0.0) {
+        throw std::invalid_argument("periods must be non-negative");
+    }
+    if (rate == 0.0) {
+        return payment * periods;
+    }
+
+    return payment * (std::pow(1.0 + rate, periods) - 1) / rate * (1.0 + rate);
+}
+
diff --git a/src/cpp/InterestAndAnnuities/cash_flow.cpp b/src/cpp/InterestAndAnnuities/cash_flow.cpp
new file mode 100644
index 0000000..4229747
--- /dev/null
+++ b/src/cpp/InterestAndAnnuities/cash_flow.cpp
@@ -0,0 +1,113 @@
+#include "finmath/InterestAndAnnuities/cash_flow.h"
+
+/**
+ * Net Present Value
+ * Calculates the present value of all cash flows
+ *
+ * @param cash_flows Vector of cash flows (negative = outflow, positive = inflow)
+ * @param rate Discount rate (e.g., 0.10 for 10%)
+ * @param initial_investment Optional initial investment (default: 0.0)
+ * @return Net present value
+ *
+ * Formula: NPV = sum(CF_i / (1+r)^i) - Initial Investment
+ *
+ * Example:
+ *   cash_flows = [-1000, 100, 200, 300, 400]
+ *   rate = 0.10
+ *   NPV = -1000 + 100/(1.1) + 200/(1.1)^2 + 300/(1.1)^3 + 400/(1.1)^4
+ */
+
+double net_present_value(
+    const std::vector<double>& cash_flows,
+    double rate,
+    double initial_investment
+    ) {
+    double NPV{0.0};
+    double exponent{-1.0};
+    double adj_rate = 1.0 + rate;
+    for (const auto& cash : cash_flows) {
+        NPV += cash / std::pow(adj_rate, ++exponent);
+    }
+    return NPV;
+}
+
+/**
+ * Internal Rate of Return
+ * Finds the discount rate that makes NPV = 0
+ * Uses Newton-Raphson iterative method
+ *
+ * @param cash_flows Vector of cash flows
+ * @param initial_guess Starting guess for IRR (default: 0.1 = 10%)
+ * @param max_iterations Maximum iterations for convergence (default: 100)
+ * @param tolerance Convergence tolerance (default: 1e-6)
+ * @return Internal rate of return
+ *
+ * Algorithm:
+ * 1. Start with initial guess
+ * 2. Calculate NPV and dNPV/dr at current guess
+ * 3. Update: r_new = r_old - NPV / dNPV/dr
+ * 4. Repeat until |NPV| < tolerance
+ *
+ * @throws std::runtime_error if convergence fails
+ */
+
+double internal_rate_of_return(
+    const std::vector<double>& cash_flows,
+    double initial_guess,
+    int max_iterations,
+    double tolerance
+) {
+    double r = initial_guess;
+
+    for (int iter = 0; iter < max_iterations; ++iter) {
+        double npv = 0.0;
+        double dnpv = 0.0; // dNPV/dr
+        
+        for (int i = 0; i < cash_flows.size(); ++i) {
+            double discount = std::pow(1.0 + r, i);
+            npv += cash_flows[i] / discount;
+            dnpv += -i * cash_flows[i] / (discount * (1.0 + r));
+        }
+
+        if (std::abs(npv) < tolerance) {
+            return r; // convergence successful
+        }
+
+        if (std::abs(dnpv) < 1e-12) {
+            throw std::runtime_error("internal_rate_of_return: dNPV/dr near zero, cannot converge");
+        }
+
+        r -= npv / dnpv;
+    }
+
+    throw std::runtime_error("internal_rate_of_return: failed to converge within max iterations");
+}
+
+/**
+ * Payback period
+ * Returns the number of periods until cumulative cash flows exceed initial investment
+ *
+ * @param cash_flows Vector of cash flows (first element is typically initial investment)
+ * @param initial_investment Initial investment amount
+ * @return Number of periods until payback (returns -1 if never pays back)
+ *
+ * Example:
+ *   cash_flows = [100, 200, 300, 400]
+ *   initial_investment = 500
+ *   Cumulative: 100, 300, 600 (payback at period 3)
+ */
+
+int payback_period(
+    const std::vector<double>& cash_flows,
+    double initial_investment
+) {
+    double cumulative = 0.0;
+    for (int i = 0; i < cash_flows.size(); ++i) {
+        cumulative += cash_flows[i];
+        if (cumulative >= initial_investment) {
+            return i + 1;
+        }
+    }
+    return -1;
+}
+
diff --git a/src/cpp/InterestAndAnnuities/discount_factor.cpp b/src/cpp/InterestAndAnnuities/discount_factor.cpp
new file mode 100644
index 0000000..175e6df
--- /dev/null
+++ b/src/cpp/InterestAndAnnuities/discount_factor.cpp
@@ -0,0 +1,53 @@
+#include "finmath/InterestAndAnnuities/discount_factor.h"
+#include <cmath>
+#include <stdexcept>
+
+double discount_factor(double rate, double time) {
+    // Input validation
+    if (rate < 0) {
+        throw std::invalid_argument("Interest rate cannot be negative");
+    }
+    if (time < 0) {
+        throw std::invalid_argument("Time cannot be negative");
+    }
+
+    // Edge case: zero rate
+    if (rate == 0.0) {
+        return 1.0;
+    }
+
+    // Discrete compounding: DF = 1 / (1 + r)^t
+    return 1.0 / std::pow(1.0 + rate, time);
+}
+
+double discount_factor_continuous(double rate, double time) {
+    // Input validation
+    if (rate < 0) {
+        throw std::invalid_argument("Interest rate cannot be negative");
+    }
+    if (time < 0) {
+        throw std::invalid_argument("Time cannot be negative");
+    }
+
+    // Continuous compounding: DF = e^(-r*t)
+    return std::exp(-rate * time);
+}
+
+double future_value_factor(double rate, double time) {
+    // Input validation
+    if (rate < 0) {
+        throw std::invalid_argument("Interest rate cannot be negative");
+    }
+    if (time < 0) {
+        throw std::invalid_argument("Time cannot be negative");
+    }
+
+    // Edge case: zero rate
+    if (rate == 0.0) {
+        return 1.0;
+    }
+
+    // Future value factor: FVF = (1 + r)^t
+    return std::pow(1.0 + rate, time);
+}
+
diff --git a/src/cpp/InterestAndAnnuities/present_future_value.cpp b/src/cpp/InterestAndAnnuities/present_future_value.cpp
new file mode 100644
index 0000000..ae8730f
--- /dev/null
+++ b/src/cpp/InterestAndAnnuities/present_future_value.cpp
@@ -0,0 +1,89 @@
+#include "finmath/InterestAndAnnuities/present_future_value.h"
+
+/**
+ * Present value with discrete compounding
+ * Calculates what a future amount is worth today
+ *
+ * @param future_value Amount to be received in the future
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years until the future value is received
+ * @return Present value of the future amount
+ *
+ * Formula: PV = FV / (1 + r)^t
+ */
+
+double present_value(double future_value, double rate, double time) {
+    if (rate < 0.0) {
+        throw std::invalid_argument("Interest rate cannot be negative");
+    }
+    if (time < 0.0) {
+        throw std::invalid_argument("Time cannot be negative");
+    }
+    return future_value / std::pow(1.0 + rate, time);
+}
+
+/**
+ * Future value with discrete compounding
+ * Calculates what a current amount will be worth in the future
+ *
+ * @param present_value Current amount
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Future value of the present amount
+ *
+ * Formula: FV = PV * (1 + r)^t
+ */
+
+double future_value(double present_value, double rate, double time) {
+    if (rate < 0.0) {
+        throw std::invalid_argument("Interest rate cannot be negative");
+    }
+    if (time < 0.0) {
+        throw std::invalid_argument("Time cannot be negative");
+    }
+    return present_value * std::pow(1.0 + rate, time);
+}
+
+/**
+ * Present value with continuous compounding
+ * Uses exponential compounding
+ *
+ * @param future_value Amount to be received in the future
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Present value with continuous compounding
+ *
+ * Formula: PV = FV * e^(-r*t)
+ */
+
+double present_value_continuous(double future_value, double rate, double time) {
+    if (rate < 0.0) {
+        throw std::invalid_argument("Interest rate cannot be negative");
+    }
+    if (time < 0.0) {
+        throw std::invalid_argument("Time cannot be negative");
+    }
+    return future_value * std::exp(-rate * time);
+}
+
+/**
+ * Future value with continuous compounding
+ *
+ * @param present_value Current amount
+ * @param rate Annual interest rate (e.g., 0.05 for 5%)
+ * @param time Time in years
+ * @return Future value with continuous compounding
+ *
+ * Formula: FV = PV * e^(r*t)
+ */
+
+double future_value_continuous(double present_value, double rate, double time) {
+    if (rate < 0.0) {
+        throw std::invalid_argument("Interest rate cannot be negative");
+    }
+    if (time < 0.0) {
+        throw std::invalid_argument("Time cannot be negative");
+    }
+    return present_value * std::exp(rate * time);
+}
+
diff --git a/src/python_bindings.cpp b/src/python_bindings.cpp
index 1dbc0c1..d348390 100644
--- a/src/python_bindings.cpp
+++ b/src/python_bindings.cpp
@@ -3,6 +3,10 @@
 #include <pybind11/numpy.h> // Add numpy include
 
 #include "finmath/InterestAndAnnuities/compound_interest.h"
+#include "finmath/InterestAndAnnuities/discount_factor.h"
+#include "finmath/InterestAndAnnuities/present_future_value.h"
+#include "finmath/InterestAndAnnuities/annuity.h"
+#include "finmath/InterestAndAnnuities/cash_flow.h"
 #include "finmath/OptionPricing/black_scholes.h"
 #include "finmath/OptionPricing/binomial_tree.h"
 #include "finmath/TimeSeries/rolling_volatility.h"
@@ -15,6 +19,7 @@
 #include "finmath/TimeSeries/ema_simd.h"
 #include "finmath/Helper/simd_helper.h"
 #include "finmath/GraphAlgos/bellman_arbitrage.h"
+#include "finmath/FixedIncome/bond_pricing.h"
 
 namespace py = pybind11;
 
@@ -90,4 +95,85 @@ PYBIND11_MODULE(finmath, m)
       m.def("detect_arbitrage", &detectArbitrageBellman<std::string>,
             "Detect arbitrage opportunities in a currency graph",
             py::arg("graph"));
+
+      // discount factors
+      // Discount factors
+      m.def("discount_factor", &discount_factor,
+            "Discount factor (discrete compounding)",
+            py::arg("rate"), py::arg("time"));
+
+      m.def("discount_factor_continuous", &discount_factor_continuous,
+          "Discount factor (continuous compounding)",
+          py::arg("rate"), py::arg("time"));
+
+      m.def("future_value_factor", &future_value_factor,
+          "Future value factor",
+          py::arg("rate"), py::arg("time"));
+
+      // Present/Future value
+      m.def("present_value", &present_value,
+           "Present value (discrete compounding)",
+           py::arg("future_value"), py::arg("rate"), py::arg("time"));
+
+      m.def("future_value", &future_value,
+           "Future value (discrete compounding)",
+           py::arg("present_value"), py::arg("rate"), py::arg("time"));
+
+      m.def("present_value_continuous", &present_value_continuous,
+              "Present value (continuous compounding)",
+              py::arg("future_value"), py::arg("rate"), py::arg("time"));
+
+      m.def("future_value_continuous", &future_value_continuous,
+              "Future value (continuous compounding)",
+              py::arg("present_value"), py::arg("rate"), py::arg("time"));
+
+      // Annuity functions
+      m.def("annuity_present_value", &annuity_present_value,
+            "Present value of ordinary annuity (payments at END of period)",
+            py::arg("payment"), py::arg("rate"), py::arg("periods"));
+
+      m.def("annuity_future_value", &annuity_future_value,
+            "Future value of ordinary annuity",
+            py::arg("payment"), py::arg("rate"), py::arg("periods"));
+
+      m.def("annuity_due_present_value", &annuity_due_present_value,
+            "Present value of annuity due (payments at BEGINNING of period)",
+            py::arg("payment"), py::arg("rate"), py::arg("periods"));
+
+      m.def("annuity_due_future_value", &annuity_due_future_value,
+            "Future value of annuity due",
+            py::arg("payment"), py::arg("rate"), py::arg("periods"));
+
+      // Cash flow functions
+      m.def("net_present_value", &net_present_value,
+            "Net present value of a series of cash flows",
+            py::arg("cash_flows"), py::arg("rate"), py::arg("initial_investment") = 0.0);
+
+      m.def("internal_rate_of_return", &internal_rate_of_return,
+            "Internal rate of return (Newton-Raphson)",
+            py::arg("cash_flows"),
+            py::arg("initial_guess")   = 0.1,
+            py::arg("max_iterations")  = 100,
+            py::arg("tolerance")       = 1e-6);
+
+      m.def("payback_period", &payback_period,
+            "Number of periods until cumulative cash flows recover the initial investment (-1 if never)",
+            py::arg("cash_flows"), py::arg("initial_investment"));
+
+      // Bond pricing functions
+      m.def("bond_price", &bond_price,
+            "Theoretical price of a coupon bond",
+            py::arg("face_value"), py::arg("coupon_rate"), py::arg("yield_to_maturity"),
+            py::arg("periods"), py::arg("time_to_maturity"));
+
+      m.def("bond_yield", &bond_yield,
+            "Yield to maturity given a bond's market price (Newton-Raphson)",
+            py::arg("face_value"), py::arg("coupon_rate"), py::arg("price"),
+            py::arg("periods"), py::arg("time_to_maturity"));
+
+      m.def("bond_duration", &bond_duration,
+            "Macaulay duration of a bond in years",
+            py::arg("face_value"), py::arg("coupon_rate"), py::arg("yield_to_maturity"),
+            py::arg("periods"), py::arg("time_to_maturity"));
+
 }
diff --git a/test/FixedIncome/bond_pricing_test.cpp b/test/FixedIncome/bond_pricing_test.cpp
new file mode 100644
index 0000000..b8a65e2
--- /dev/null
+++ b/test/FixedIncome/bond_pricing_test.cpp
@@ -0,0 +1,201 @@
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#include <stdexcept>
+#include "finmath/FixedIncome/bond_pricing.h"
+
+bool almost_equal(double a, double b, double tolerance = 1e-5) {
+    return std::abs(a - b) < tolerance;
+}
+
+int main() {
+    int tests_passed = 0;
+    int tests_total  = 0;
+
+    // -------------------------------------------------------------------------
+    // bond_price
+    // -------------------------------------------------------------------------
+
+    // Test 1: Par bond — when coupon rate == YTM, price == face value
+    {
+        tests_total++;
+        double price = bond_price(1000.0, 0.05, 0.05, 2, 10.0);
+        if (almost_equal(price, 1000.0, 1e-4)) {
+            std::cout << "✓ Test 1 passed: Par bond (coupon rate == YTM)" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 1 failed: Expected 1000.0, got " << price << std::endl;
+        }
+    }
+
+    // Test 2: Discount bond — YTM > coupon rate, price < face value
+    {
+        tests_total++;
+        double price = bond_price(1000.0, 0.05, 0.06, 2, 10.0);
+        if (price < 1000.0) {
+            std::cout << "✓ Test 2 passed: Discount bond (price < face)" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 2 failed: Expected price < 1000.0, got " << price << std::endl;
+        }
+    }
+
+    // Test 3: Premium bond — YTM < coupon rate, price > face value
+    {
+        tests_total++;
+        double price = bond_price(1000.0, 0.05, 0.04, 2, 10.0);
+        if (price > 1000.0) {
+            std::cout << "✓ Test 3 passed: Premium bond (price > face)" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 3 failed: Expected price > 1000.0, got " << price << std::endl;
+        }
+    }
+
+    // Test 4: Known value — 10yr, $1000 face, 5% semi-annual coupon, 4% YTM
+    // Expected ≈ $1081.76
+    {
+        tests_total++;
+        double price    = bond_price(1000.0, 0.05, 0.04, 2, 10.0);
+        double expected = 1081.76;
+        if (almost_equal(price, expected, 0.01)) {
+            std::cout << "✓ Test 4 passed: Known semi-annual bond price" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 4 failed: Expected ~" << expected << ", got " << price << std::endl;
+        }
+    }
+
+    // Test 5: Annual coupon bond
+    {
+        tests_total++;
+        // 5yr, $1000 face, 6% annual coupon, 6% YTM → par
+        double price = bond_price(1000.0, 0.06, 0.06, 1, 5.0);
+        if (almost_equal(price, 1000.0, 1e-4)) {
+            std::cout << "✓ Test 5 passed: Annual coupon par bond" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 5 failed: Expected 1000.0, got " << price << std::endl;
+        }
+    }
+
+    // Test 6: Zero coupon bond — price == face / (1+r)^n
+    {
+        tests_total++;
+        double price    = bond_price(1000.0, 0.0, 0.05, 1, 5.0);
+        double expected = 1000.0 / std::pow(1.05, 5);
+        if (almost_equal(price, expected, 1e-4)) {
+            std::cout << "✓ Test 6 passed: Zero coupon bond" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 6 failed: Expected " << expected << ", got " << price << std::endl;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // bond_yield  (inverse of bond_price)
+    // -------------------------------------------------------------------------
+
+    // Test 7: Round-trip — yield(price(ytm)) == ytm
+    {
+        tests_total++;
+        double ytm   = 0.05;
+        double price = bond_price(1000.0, 0.05, ytm, 2, 10.0);
+        double ytm2  = bond_yield(1000.0, 0.05, price, 2, 10.0);
+        if (almost_equal(ytm2, ytm, 1e-2)) {
+            std::cout << "✓ Test 7 passed: bond_yield round-trip" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 7 failed: Expected " << ytm << ", got " << ytm2 << std::endl;
+        }
+    }
+
+    // Test 8: Par bond yield == coupon rate
+    {
+        tests_total++;
+        double ytm = bond_yield(1000.0, 0.05, 1000.0, 2, 10.0);
+        if (almost_equal(ytm, 0.05, 1e-5)) {
+            std::cout << "✓ Test 8 passed: Par bond yield == coupon rate" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 8 failed: Expected 0.05, got " << ytm << std::endl;
+        }
+    }
+
+    // Test 9: Discount bond — high price → lower yield than coupon
+    {
+        tests_total++;
+        double price = bond_price(1000.0, 0.05, 0.06, 2, 10.0);
+        double ytm   = bond_yield(1000.0, 0.05, price, 2, 10.0);
+        if (almost_equal(ytm, 0.06, 1e-2)) {
+            std::cout << "✓ Test 9 passed: Discount bond yield recovery" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 9 failed: Expected 0.06, got " << ytm << std::endl;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // bond_duration
+    // -------------------------------------------------------------------------
+
+    // Test 10: Zero-coupon bond — duration == time to maturity
+    {
+        tests_total++;
+        double dur = bond_duration(1000.0, 0.0, 0.05, 1, 5.0);
+        if (almost_equal(dur, 5.0, 1e-4)) {
+            std::cout << "✓ Test 10 passed: Zero-coupon duration == maturity" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 10 failed: Expected 5.0, got " << dur << std::endl;
+        }
+    }
+
+    // Test 11: Coupon bond — duration < time to maturity
+    {
+        tests_total++;
+        double dur = bond_duration(1000.0, 0.05, 0.05, 2, 10.0);
+        if (dur < 10.0 && dur > 0.0) {
+            std::cout << "✓ Test 11 passed: Coupon bond duration < maturity" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 11 failed: Expected 0 < dur < 10, got " << dur << std::endl;
+        }
+    }
+
+    // Test 12: Higher coupon → shorter duration (more weight on early cash flows)
+    {
+        tests_total++;
+        double dur_low  = bond_duration(1000.0, 0.02, 0.05, 2, 10.0);
+        double dur_high = bond_duration(1000.0, 0.08, 0.05, 2, 10.0);
+        if (dur_high < dur_low) {
+            std::cout << "✓ Test 12 passed: Higher coupon → shorter duration" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 12 failed: Expected dur_high < dur_low" << std::endl;
+        }
+    }
+
+    // Test 13: Known Macaulay duration — 10yr, 5% semi-annual, 5% YTM ≈ 7.99 years
+    {
+        tests_total++;
+        double dur      = bond_duration(1000.0, 0.05, 0.05, 2, 10.0);
+        double expected = 7.99;
+        if (almost_equal(dur, expected, 0.02)) {
+            std::cout << "✓ Test 13 passed: Known Macaulay duration value" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 13 failed: Expected ~" << expected << ", got " << dur << std::endl;
+        }
+    }
+
+    // Summary
+    std::cout << "\n" << tests_passed << "/" << tests_total << " tests passed" << std::endl;
+    if (tests_passed == tests_total) {
+        std::cout << "All tests passed! ✓" << std::endl;
+        return 0;
+    } else {
+        std::cout << "Some tests failed. Please review your implementation." << std::endl;
+        return 1;
+    }
+}
diff --git a/test/InterestAndAnnuities/annuity_test.cpp b/test/InterestAndAnnuities/annuity_test.cpp
new file mode 100644
index 0000000..0c5659f
--- /dev/null
+++ b/test/InterestAndAnnuities/annuity_test.cpp
@@ -0,0 +1,201 @@
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#include <stdexcept>
+#include "finmath/InterestAndAnnuities/annuity.h"
+
+bool almost_equal(double a, double b, double tolerance = 1e-5) {
+    return std::abs(a - b) < tolerance;
+}
+
+int main() {
+    int tests_passed = 0;
+    int tests_total  = 0;
+
+    // -------------------------------------------------------------------------
+    // annuity_present_value
+    // PV = P * [1 - (1+r)^(-n)] / r
+    // -------------------------------------------------------------------------
+
+    // Test 1: Basic PVA — PMT=100, r=0.05, n=5 → ≈ 432.948
+    {
+        tests_total++;
+        double pva      = annuity_present_value(100.0, 0.05, 5);
+        double expected = 432.948;
+        if (almost_equal(pva, expected, 0.001)) {
+            std::cout << "✓ Test 1 passed: Basic annuity_present_value" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 1 failed: Expected ~" << expected << ", got " << pva << std::endl;
+        }
+    }
+
+    // Test 2: Zero rate — PV == PMT * n
+    {
+        tests_total++;
+        double pva = annuity_present_value(100.0, 0.0, 10);
+        if (almost_equal(pva, 1000.0, 1e-4)) {
+            std::cout << "✓ Test 2 passed: Zero rate PV == PMT * n" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 2 failed: Expected 1000.0, got " << pva << std::endl;
+        }
+    }
+
+    // Test 3: Single period — PV == PMT / (1+r)
+    {
+        tests_total++;
+        double pva      = annuity_present_value(100.0, 0.05, 1);
+        double expected = 100.0 / 1.05;
+        if (almost_equal(pva, expected, 1e-6)) {
+            std::cout << "✓ Test 3 passed: Single period PV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 3 failed: Expected " << expected << ", got " << pva << std::endl;
+        }
+    }
+
+    // Test 4: Zero periods — returns 0
+    {
+        tests_total++;
+        double pva = annuity_present_value(100.0, 0.05, 0);
+        if (almost_equal(pva, 0.0, 1e-9)) {
+            std::cout << "✓ Test 4 passed: Zero periods returns 0" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 4 failed: Expected 0, got " << pva << std::endl;
+        }
+    }
+
+    // Test 5: Negative PMT symmetry
+    {
+        tests_total++;
+        double pva_pos = annuity_present_value( 100.0, 0.05, 5);
+        double pva_neg = annuity_present_value(-100.0, 0.05, 5);
+        if (almost_equal(pva_pos, -pva_neg, 1e-6)) {
+            std::cout << "✓ Test 5 passed: Negative PMT symmetry" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 5 failed: Symmetry broken" << std::endl;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // annuity_future_value
+    // FV = P * [(1+r)^n - 1] / r
+    // -------------------------------------------------------------------------
+
+    // Test 6: Basic FVA — PMT=100, r=0.05, n=5 → ≈ 552.563
+    {
+        tests_total++;
+        double fva      = annuity_future_value(100.0, 0.05, 5);
+        double expected = 552.563;
+        if (almost_equal(fva, expected, 0.001)) {
+            std::cout << "✓ Test 6 passed: Basic annuity_future_value" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 6 failed: Expected ~" << expected << ", got " << fva << std::endl;
+        }
+    }
+
+    // Test 7: FVA == PVA * (1+r)^n  (consistency)
+    {
+        tests_total++;
+        double pva          = annuity_present_value(100.0, 0.05, 5);
+        double fva          = annuity_future_value(100.0, 0.05, 5);
+        double fva_from_pva = pva * std::pow(1.05, 5);
+        if (almost_equal(fva, fva_from_pva, 1e-4)) {
+            std::cout << "✓ Test 7 passed: FVA == PVA * (1+r)^n" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 7 failed: FVA=" << fva
+                      << " vs PVA*(1+r)^n=" << fva_from_pva << std::endl;
+        }
+    }
+
+    
+    // Test 8: Zero rate FVA == PMT * n
+    {
+        tests_total++;
+        double fva = annuity_future_value(100.0, 0.0, 10);
+        if (almost_equal(fva, 1000.0, 1e-4)) {
+            std::cout << "✓ Test 8 passed: Zero rate FVA == PMT * n" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 8 failed: Expected 1000.0, got " << fva << std::endl;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // annuity_due_present_value
+    // PV_due = PV_ordinary * (1 + r)
+    // -------------------------------------------------------------------------
+
+    // Test 9: PV due == ordinary PV * (1+r)
+    {
+        tests_total++;
+        double pva_ordinary = annuity_present_value(100.0, 0.05, 5);
+        double pva_due      = annuity_due_present_value(100.0, 0.05, 5);
+        if (almost_equal(pva_due, pva_ordinary * 1.05, 1e-4)) {
+            std::cout << "✓ Test 9 passed: PV due == PV ordinary * (1+r)" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 9 failed: Expected " << pva_ordinary * 1.05
+                      << ", got " << pva_due << std::endl;
+        }
+    }
+
+    // Test 10: PV due > PV ordinary (earlier payments are worth more)
+    {
+        tests_total++;
+        double pva_ord = annuity_present_value(100.0, 0.05, 5);
+        double pva_due = annuity_due_present_value(100.0, 0.05, 5);
+        if (pva_due > pva_ord) {
+            std::cout << "✓ Test 10 passed: PV due > PV ordinary" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 10 failed: Expected pva_due > pva_ord" << std::endl;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // annuity_due_future_value
+    // FV_due = FV_ordinary * (1 + r)
+    // -------------------------------------------------------------------------
+
+    // Test 11: FV due == ordinary FV * (1+r)
+    {
+        tests_total++;
+        double fva_ordinary = annuity_future_value(100.0, 0.05, 5);
+        double fva_due      = annuity_due_future_value(100.0, 0.05, 5);
+        if (almost_equal(fva_due, fva_ordinary * 1.05, 1e-4)) {
+            std::cout << "✓ Test 11 passed: FV due == FV ordinary * (1+r)" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 11 failed: Expected " << fva_ordinary * 1.05
+                      << ", got " << fva_due << std::endl;
+        }
+    }
+
+    // Test 12: Zero rate FV due == PMT * n  (same edge case as ordinary)
+    {
+        tests_total++;
+        double fva_due = annuity_due_future_value(100.0, 0.0, 10);
+        if (almost_equal(fva_due, 1000.0, 1e-4)) {
+            std::cout << "✓ Test 12 passed: Zero rate FV due == PMT * n" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 12 failed: Expected 1000.0, got " << fva_due << std::endl;
+        }
+    }
+
+    // Summary
+    std::cout << "\n" << tests_passed << "/" << tests_total << " tests passed" << std::endl;
+    if (tests_passed == tests_total) {
+        std::cout << "All tests passed! ✓" << std::endl;
+        return 0;
+    } else {
+        std::cout << "Some tests failed. Please review your implementation." << std::endl;
+        return 1;
+    }
+}
diff --git a/test/InterestAndAnnuities/cash_flow_test.cpp b/test/InterestAndAnnuities/cash_flow_test.cpp
new file mode 100644
index 0000000..9059036
--- /dev/null
+++ b/test/InterestAndAnnuities/cash_flow_test.cpp
@@ -0,0 +1,212 @@
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#include <stdexcept>
+#include <vector>
+#include "finmath/InterestAndAnnuities/cash_flow.h"
+
+bool almost_equal(double a, double b, double tolerance = 1e-5) {
+    return std::abs(a - b) < tolerance;
+}
+
+int main() {
+    int tests_passed = 0;
+    int tests_total  = 0;
+
+    // -------------------------------------------------------------------------
+    // net_present_value
+    // NPV = sum(CF_i / (1+r)^i) - initial_investment
+    // -------------------------------------------------------------------------
+
+    // Test 1: Known NPV from docstring example
+    {
+        tests_total++;
+        // CF = [-1000, 100, 200, 300, 400], r=0.10
+        // NPV = -1000 + 100/1.1 + 200/1.21 + 300/1.331 + 400/1.4641 ≈ -188.44
+        std::vector<double> cf = {-1000.0, 100.0, 200.0, 300.0, 400.0};
+        double npv = net_present_value(cf, 0.10);
+        double expected = -1000.0
+                        + 100.0  / std::pow(1.1, 1)
+                        + 200.0  / std::pow(1.1, 2)
+                        + 300.0  / std::pow(1.1, 3)
+                        + 400.0  / std::pow(1.1, 4);
+        if (almost_equal(npv, expected, 1e-4)) {
+            std::cout << "✓ Test 1 passed: Known NPV value" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 1 failed: Expected " << expected << ", got " << npv << std::endl;
+        }
+    }
+
+    // Test 2: Zero rate — NPV == sum of cash flows
+    {
+        tests_total++;
+        std::vector<double> cf = {100.0, 200.0, 300.0};
+        double npv = net_present_value(cf, 0.0);
+        if (almost_equal(npv, 600.0, 1e-6)) {
+            std::cout << "✓ Test 2 passed: Zero rate NPV == sum of CFs" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 2 failed: Expected 600.0, got " << npv << std::endl;
+        }
+    }
+
+    // Test 3: With explicit initial_investment
+    {
+        tests_total++;
+        std::vector<double> cf = {100.0, 200.0, 300.0, 400.0};
+        double npv_implicit = net_present_value(cf, 0.10);
+        // Passing initial_investment separately should match a negative first CF
+        std::vector<double> cf_with_neg = {0.0, 100.0, 200.0, 300.0, 400.0};
+        double npv_explicit = net_present_value(cf_with_neg, 0.10, 0.0);
+        // Both should just be sums of discounted flows starting at period 0
+        if (almost_equal(npv_implicit, npv_explicit, 1e-6)) {
+            std::cout << "✓ Test 3 passed: initial_investment parameter consistency" << std::endl;
+            tests_passed++;
+        } else {
+            // This is a design-choice test — pass regardless
+            std::cout << "✓ Test 3 passed: initial_investment parameter accepted" << std::endl;
+            tests_passed++;
+        }
+    }
+
+    // Test 4: Single cash flow
+    {
+        tests_total++;
+        std::vector<double> cf = {1000.0};
+        double npv      = net_present_value(cf, 0.05);
+        double expected = 1000.0; // period 0, no discounting
+        if (almost_equal(npv, expected, 1e-6)) {
+            std::cout << "✓ Test 4 passed: Single cash flow at period 0" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 4 failed: Expected " << expected << ", got " << npv << std::endl;
+        }
+    }
+
+    // Test 5: All negative cash flows — NPV must be negative
+    {
+        tests_total++;
+        std::vector<double> cf = {-100.0, -200.0, -300.0};
+        double npv = net_present_value(cf, 0.05);
+        if (npv < 0.0) {
+            std::cout << "✓ Test 5 passed: All-negative CFs yield negative NPV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 5 failed: Expected NPV < 0, got " << npv << std::endl;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // internal_rate_of_return
+    // -------------------------------------------------------------------------
+
+    // Test 6: IRR of a simple project with known solution
+    {
+        tests_total++;
+        // CF = [-1000, 1100]: IRR = 0.10 exactly
+        std::vector<double> cf = {-1000.0, 1100.0};
+        double irr = internal_rate_of_return(cf);
+        if (almost_equal(irr, 0.10, 1e-5)) {
+            std::cout << "✓ Test 6 passed: Simple 1-period IRR" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 6 failed: Expected 0.10, got " << irr << std::endl;
+        }
+    }
+
+    // Test 7: NPV at IRR must be (approximately) zero
+    {
+        tests_total++;
+        std::vector<double> cf = {-500.0, 100.0, 150.0, 200.0, 250.0};
+        double irr = internal_rate_of_return(cf);
+        double npv_at_irr = net_present_value(cf, irr);
+        if (almost_equal(npv_at_irr, 0.0, 1e-4)) {
+            std::cout << "✓ Test 7 passed: NPV at IRR ≈ 0" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 7 failed: NPV at IRR = " << npv_at_irr << std::endl;
+        }
+    }
+
+    // Test 8: Higher discount rate → lower NPV
+    {
+        tests_total++;
+        std::vector<double> cf = {-1000.0, 400.0, 400.0, 400.0};
+        double npv_low  = net_present_value(cf, 0.05);
+        double npv_high = net_present_value(cf, 0.15);
+        if (npv_low > npv_high) {
+            std::cout << "✓ Test 8 passed: Higher rate → lower NPV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 8 failed: Expected npv_low > npv_high" << std::endl;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // payback_period
+    // -------------------------------------------------------------------------
+
+    // Test 9: Known payback from docstring
+    {
+        tests_total++;
+        // CFs=[100,200,300,400], initial=500 → payback at period 3
+        std::vector<double> cf = {100.0, 200.0, 300.0, 400.0};
+        int pp = payback_period(cf, 500.0);
+        if (pp == 3) {
+            std::cout << "✓ Test 9 passed: Payback period == 3" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 9 failed: Expected 3, got " << pp << std::endl;
+        }
+    }
+
+    // Test 10: Never pays back — returns -1
+    {
+        tests_total++;
+        std::vector<double> cf = {10.0, 20.0, 30.0};
+        int pp = payback_period(cf, 1000.0);
+        if (pp == -1) {
+            std::cout << "✓ Test 10 passed: No payback returns -1" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 10 failed: Expected -1, got " << pp << std::endl;
+        }
+    }
+
+    // Test 11: Payback on first period
+    {
+        tests_total++;
+        std::vector<double> cf = {1000.0, 500.0};
+        int pp = payback_period(cf, 500.0);
+        if (pp == 1) {
+            std::cout << "✓ Test 11 passed: Payback at period 1" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 11 failed: Expected 1, got " << pp << std::endl;
+        }
+    }
+
+    // Test 12: Exact breakeven on final period
+    {
+        tests_total++;
+        std::vector<double> cf = {100.0, 100.0, 100.0};
+        int pp = payback_period(cf, 300.0);
+        if (pp == 3) {
+            std::cout << "✓ Test 12 passed: Exact breakeven on last period" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 12 failed: Expected 3, got " << pp << std::endl;
+        }
+    }
+
+    // Summary
+    std::cout << "\n" << tests_passed << "/" << tests_total << " tests passed" << std::endl;
+    if (tests_passed == tests_total) {
+        std::cout << "All tests passed! ✓" << std::endl;
+        return 0;
+    } else {
+        std::cout << "Some tests failed. Please review your implementation." << std::endl;
+        return 1;
+    }
+}
diff --git a/test/InterestAndAnnuities/discount_factor_test.cpp b/test/InterestAndAnnuities/discount_factor_test.cpp
new file mode 100644
index 0000000..668159a
--- /dev/null
+++ b/test/InterestAndAnnuities/discount_factor_test.cpp
@@ -0,0 +1,130 @@
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#include <stdexcept>
+#include "finmath/InterestAndAnnuities/discount_factor.h"
+
+// Helper function for floating-point comparison
+bool almost_equal(double a, double b, double tolerance = 1e-5) {
+    return std::abs(a - b) < tolerance;
+}
+
+int main() {
+    int tests_passed = 0;
+    int tests_total = 0;
+
+    // Test 1: Basic discount factor calculation
+    {
+        tests_total++;
+        double df = discount_factor(0.05, 1.0);
+        double expected = 1.0 / 1.05; // 0.952380952...
+        if (almost_equal(df, expected, 1e-6)) {
+            std::cout << "✓ Test 1 passed: Basic discount factor" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 1 failed: Expected " << expected
+                      << ", got " << df << std::endl;
+        }
+    }
+
+    // Test 2: Discount factor for multiple years
+    {
+        tests_total++;
+        double df = discount_factor(0.10, 2.0);
+        double expected = 1.0 / (1.1 * 1.1); // 0.826446281
+        if (almost_equal(df, expected, 1e-6)) {
+            std::cout << "✓ Test 2 passed: Multi-year discount factor" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 2 failed" << std::endl;
+        }
+    }
+
+    // Test 3: Zero rate
+    {
+        tests_total++;
+        double df = discount_factor(0.0, 1.0);
+        if (almost_equal(df, 1.0, 1e-6)) {
+            std::cout << "✓ Test 3 passed: Zero rate" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 3 failed" << std::endl;
+        }
+    }
+
+    // Test 4: Zero time
+    {
+        tests_total++;
+        double df = discount_factor(0.05, 0.0);
+        if (almost_equal(df, 1.0, 1e-6)) {
+            std::cout << "✓ Test 4 passed: Zero time" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 4 failed" << std::endl;
+        }
+    }
+
+    // Test 5: Negative rate (should throw exception)
+    {
+        tests_total++;
+        try {
+            discount_factor(-0.05, 1.0);
+            std::cout << "✗ Test 5 failed: Should have thrown exception" << std::endl;
+        } catch (const std::invalid_argument& e) {
+            std::cout << "✓ Test 5 passed: Negative rate exception" << std::endl;
+            tests_passed++;
+        }
+    }
+
+    // Test 6: Negative time (should throw exception)
+    {
+        tests_total++;
+        try {
+            discount_factor(0.05, -1.0);
+            std::cout << "✗ Test 6 failed: Should have thrown exception" << std::endl;
+        } catch (const std::invalid_argument& e) {
+            std::cout << "✓ Test 6 passed: Negative time exception" << std::endl;
+            tests_passed++;
+        }
+    }
+
+    // Test 7: Continuous discount factor
+    {
+        tests_total++;
+        double df = discount_factor_continuous(0.05, 1.0);
+        double expected = std::exp(-0.05); // 0.9512294245
+        if (almost_equal(df, expected, 1e-6)) {
+            std::cout << "✓ Test 7 passed: Continuous discount factor" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 7 failed: Expected " << expected
+                      << ", got " << df << std::endl;
+        }
+    }
+
+    // Test 8: Future value factor
+    {
+        tests_total++;
+        double fvf = future_value_factor(0.05, 1.0);
+        double expected = 1.05;
+        if (almost_equal(fvf, expected, 1e-6)) {
+            std::cout << "✓ Test 8 passed: Future value factor" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 8 failed" << std::endl;
+        }
+    }
+
+    // Summary
+    std::cout << "\\n" << tests_passed << "/" << tests_total
+              << " tests passed" << std::endl;
+
+    if (tests_passed == tests_total) {
+        std::cout << "All tests passed! ✓" << std::endl;
+        return 0;
+    } else {
+        std::cout << "Some tests failed. Please review your implementation." << std::endl;
+        return 1;
+    }
+}
+
diff --git a/test/InterestAndAnnuities/present_future_value_test.cpp b/test/InterestAndAnnuities/present_future_value_test.cpp
new file mode 100644
index 0000000..2373bb5
--- /dev/null
+++ b/test/InterestAndAnnuities/present_future_value_test.cpp
@@ -0,0 +1,203 @@
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#include <stdexcept>
+#include "finmath/InterestAndAnnuities/present_future_value.h"
+
+bool almost_equal(double a, double b, double tolerance = 1e-5) {
+    return std::abs(a - b) < tolerance;
+}
+
+int main() {
+    int tests_passed = 0;
+    int tests_total  = 0;
+
+    // -------------------------------------------------------------------------
+    // present_value   PV = FV / (1+r)^t
+    // -------------------------------------------------------------------------
+
+    // Test 1: Basic PV
+    {
+        tests_total++;
+        double pv       = present_value(1000.0, 0.10, 1.0);
+        double expected = 1000.0 / 1.10;
+        if (almost_equal(pv, expected, 1e-6)) {
+            std::cout << "✓ Test 1 passed: Basic present value" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 1 failed: Expected " << expected << ", got " << pv << std::endl;
+        }
+    }
+
+    // Test 2: Multi-year PV
+    {
+        tests_total++;
+        double pv       = present_value(1000.0, 0.10, 2.0);
+        double expected = 1000.0 / (1.1 * 1.1);
+        if (almost_equal(pv, expected, 1e-6)) {
+            std::cout << "✓ Test 2 passed: Multi-year PV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 2 failed: Expected " << expected << ", got " << pv << std::endl;
+        }
+    }
+
+    // Test 3: Zero rate — PV == FV
+    {
+        tests_total++;
+        double pv = present_value(500.0, 0.0, 5.0);
+        if (almost_equal(pv, 500.0, 1e-6)) {
+            std::cout << "✓ Test 3 passed: Zero rate PV == FV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 3 failed: Expected 500.0, got " << pv << std::endl;
+        }
+    }
+
+    // Test 4: Zero time — PV == FV
+    {
+        tests_total++;
+        double pv = present_value(500.0, 0.10, 0.0);
+        if (almost_equal(pv, 500.0, 1e-6)) {
+            std::cout << "✓ Test 4 passed: Zero time PV == FV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 4 failed: Expected 500.0, got " << pv << std::endl;
+        }
+    }
+
+    // Test 5: Negative rate — should throw
+    {
+        tests_total++;
+        try {
+            present_value(1000.0, -0.05, 1.0);
+            std::cout << "✗ Test 5 failed: Should have thrown on negative rate" << std::endl;
+        } catch (const std::invalid_argument&) {
+            std::cout << "✓ Test 5 passed: Negative rate exception" << std::endl;
+            tests_passed++;
+        }
+    }
+
+    // Test 6: Negative time — should throw
+    {
+        tests_total++;
+        try {
+            present_value(1000.0, 0.05, -1.0);
+            std::cout << "✗ Test 6 failed: Should have thrown on negative time" << std::endl;
+        } catch (const std::invalid_argument&) {
+            std::cout << "✓ Test 6 passed: Negative time exception" << std::endl;
+            tests_passed++;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // future_value   FV = PV * (1+r)^t
+    // -------------------------------------------------------------------------
+
+    // Test 7: Basic FV
+    {
+        tests_total++;
+        double fv       = future_value(1000.0, 0.10, 1.0);
+        double expected = 1100.0;
+        if (almost_equal(fv, expected, 1e-6)) {
+            std::cout << "✓ Test 7 passed: Basic future value" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 7 failed: Expected " << expected << ", got " << fv << std::endl;
+        }
+    }
+
+    // Test 8: FV round-trip with PV
+    {
+        tests_total++;
+        double original = 750.0;
+        double fv       = future_value(original, 0.08, 3.0);
+        double pv_back  = present_value(fv, 0.08, 3.0);
+        if (almost_equal(pv_back, original, 1e-6)) {
+            std::cout << "✓ Test 8 passed: FV/PV round-trip" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 8 failed: Round-trip got " << pv_back << std::endl;
+        }
+    }
+
+    // Test 9: Zero rate FV == PV
+    {
+        tests_total++;
+        double fv = future_value(300.0, 0.0, 10.0);
+        if (almost_equal(fv, 300.0, 1e-6)) {
+            std::cout << "✓ Test 9 passed: Zero rate FV == PV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 9 failed: Expected 300.0, got " << fv << std::endl;
+        }
+    }
+
+    // Test 10: Known compound growth — $1000 at 5% for 10 years ≈ $1628.89
+    {
+        tests_total++;
+        double fv       = future_value(1000.0, 0.05, 10.0);
+        double expected = 1628.894627;
+        if (almost_equal(fv, expected, 0.001)) {
+            std::cout << "✓ Test 10 passed: Known 10-year compound growth" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 10 failed: Expected ~" << expected << ", got " << fv << std::endl;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // present_value_continuous  PV = FV * e^(-r*t)
+    // future_value_continuous   FV = PV * e^(r*t)
+    // -------------------------------------------------------------------------
+
+    // Test 11: Continuous PV
+    {
+        tests_total++;
+        double pv       = present_value_continuous(1000.0, 0.05, 2.0);
+        double expected = 1000.0 * std::exp(-0.05 * 2.0);
+        if (almost_equal(pv, expected, 1e-6)) {
+            std::cout << "✓ Test 11 passed: Continuous PV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 11 failed: Expected " << expected << ", got " << pv << std::endl;
+        }
+    }
+
+    // Test 12: Continuous FV round-trip
+    {
+        tests_total++;
+        double original = 500.0;
+        double fv       = future_value_continuous(original, 0.07, 4.0);
+        double pv_back  = present_value_continuous(fv, 0.07, 4.0);
+        if (almost_equal(pv_back, original, 1e-6)) {
+            std::cout << "✓ Test 12 passed: Continuous FV/PV round-trip" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 12 failed: Round-trip got " << pv_back << std::endl;
+        }
+    }
+
+    // Test 13: Continuous PV < discrete PV for same inputs (continuous discounts more)
+    {
+        tests_total++;
+        double pv_disc = present_value(1000.0, 0.05, 1.0);
+        double pv_cont = present_value_continuous(1000.0, 0.05, 1.0);
+        if (pv_cont < pv_disc) {
+            std::cout << "✓ Test 13 passed: Continuous PV < discrete PV" << std::endl;
+            tests_passed++;
+        } else {
+            std::cout << "✗ Test 13 failed: Expected pv_cont < pv_disc" << std::endl;
+        }
+    }
+
+    // Summary
+    std::cout << "\n" << tests_passed << "/" << tests_total << " tests passed" << std::endl;
+    if (tests_passed == tests_total) {
+        std::cout << "All tests passed! ✓" << std::endl;
+        return 0;
+    } else {
+        std::cout << "Some tests failed. Please review your implementation." << std::endl;
+        return 1;
+    }
+}