init

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/CashFlowValidations.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\FinancialValidations;
+use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
+
+class CashFlowValidations extends FinancialValidations
+{
+    public static function validateRate(mixed $rate): float
+    {
+        $rate = self::validateFloat($rate);
+
+        return $rate;
+    }
+
+    public static function validatePeriodType(mixed $type): int
+    {
+        $rate = self::validateInt($type);
+        if (
+            $type !== FinancialConstants::PAYMENT_END_OF_PERIOD
+            && $type !== FinancialConstants::PAYMENT_BEGINNING_OF_PERIOD
+        ) {
+            throw new Exception(ExcelError::NAN());
+        }
+
+        return $rate;
+    }
+
+    public static function validatePresentValue(mixed $presentValue): float
+    {
+        return self::validateFloat($presentValue);
+    }
+
+    public static function validateFutureValue(mixed $futureValue): float
+    {
+        return self::validateFloat($futureValue);
+    }
+}

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic.php

@@ -0,0 +1,195 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\CashFlowValidations;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
+
+class Periodic
+{
+    /**
+     * FV.
+     *
+     * Returns the Future Value of a cash flow with constant payments and interest rate (annuities).
+     *
+     * Excel Function:
+     *        FV(rate,nper,pmt[,pv[,type]])
+     *
+     * @param mixed $rate The interest rate per period
+     * @param mixed $numberOfPeriods Total number of payment periods in an annuity as an integer
+     * @param mixed $payment The payment made each period: it cannot change over the
+     *                            life of the annuity. Typically, pmt contains principal
+     *                            and interest but no other fees or taxes.
+     * @param mixed $presentValue present Value, or the lump-sum amount that a series of
+     *                            future payments is worth right now
+     * @param mixed $type A number 0 or 1 and indicates when payments are due:
+     *                      0 or omitted    At the end of the period.
+     *                      1               At the beginning of the period.
+     */
+    public static function futureValue(
+        mixed $rate,
+        mixed $numberOfPeriods,
+        mixed $payment = 0.0,
+        mixed $presentValue = 0.0,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ): string|float {
+        $rate = Functions::flattenSingleValue($rate);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $payment = ($payment === null) ? 0.0 : Functions::flattenSingleValue($payment);
+        $presentValue = ($presentValue === null) ? 0.0 : Functions::flattenSingleValue($presentValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $payment = CashFlowValidations::validateFloat($payment);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return self::calculateFutureValue($rate, $numberOfPeriods, $payment, $presentValue, $type);
+    }
+
+    /**
+     * PV.
+     *
+     * Returns the Present Value of a cash flow with constant payments and interest rate (annuities).
+     *
+     * @param mixed $rate Interest rate per period
+     * @param mixed $numberOfPeriods Number of periods as an integer
+     * @param mixed $payment Periodic payment (annuity)
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function presentValue(
+        mixed $rate,
+        mixed $numberOfPeriods,
+        mixed $payment = 0.0,
+        mixed $futureValue = 0.0,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ): string|float {
+        $rate = Functions::flattenSingleValue($rate);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $payment = ($payment === null) ? 0.0 : Functions::flattenSingleValue($payment);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $payment = CashFlowValidations::validateFloat($payment);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($numberOfPeriods < 0) {
+            return ExcelError::NAN();
+        }
+
+        return self::calculatePresentValue($rate, $numberOfPeriods, $payment, $futureValue, $type);
+    }
+
+    /**
+     * NPER.
+     *
+     * Returns the number of periods for a cash flow with constant periodic payments (annuities), and interest rate.
+     *
+     * @param mixed $rate Interest rate per period
+     * @param mixed $payment Periodic payment (annuity)
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function periods(
+        mixed $rate,
+        mixed $payment,
+        mixed $presentValue,
+        mixed $futureValue = 0.0,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $rate = Functions::flattenSingleValue($rate);
+        $payment = Functions::flattenSingleValue($payment);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $payment = CashFlowValidations::validateFloat($payment);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($payment == 0.0) {
+            return ExcelError::NAN();
+        }
+
+        return self::calculatePeriods($rate, $payment, $presentValue, $futureValue, $type);
+    }
+
+    private static function calculateFutureValue(
+        float $rate,
+        int $numberOfPeriods,
+        float $payment,
+        float $presentValue,
+        int $type
+    ): float {
+        if ($rate !== null && $rate != 0) {
+            return -$presentValue
+                * (1 + $rate) ** $numberOfPeriods - $payment * (1 + $rate * $type) * ((1 + $rate) ** $numberOfPeriods - 1)
+                    / $rate;
+        }
+
+        return -$presentValue - $payment * $numberOfPeriods;
+    }
+
+    private static function calculatePresentValue(
+        float $rate,
+        int $numberOfPeriods,
+        float $payment,
+        float $futureValue,
+        int $type
+    ): float {
+        if ($rate != 0.0) {
+            return (-$payment * (1 + $rate * $type)
+                    * (((1 + $rate) ** $numberOfPeriods - 1) / $rate) - $futureValue) / (1 + $rate) ** $numberOfPeriods;
+        }
+
+        return -$futureValue - $payment * $numberOfPeriods;
+    }
+
+    private static function calculatePeriods(
+        float $rate,
+        float $payment,
+        float $presentValue,
+        float $futureValue,
+        int $type
+    ): string|float {
+        if ($rate != 0.0) {
+            if ($presentValue == 0.0) {
+                return ExcelError::NAN();
+            }
+
+            return log(($payment * (1 + $rate * $type) / $rate - $futureValue)
+                    / ($presentValue + $payment * (1 + $rate * $type) / $rate)) / log(1 + $rate);
+        }
+
+        return (-$presentValue - $futureValue) / $payment;
+    }
+}

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic/Cumulative.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant\Periodic;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\CashFlowValidations;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
+
+class Cumulative
+{
+    /**
+     * CUMIPMT.
+     *
+     * Returns the cumulative interest paid on a loan between the start and end periods.
+     *
+     * Excel Function:
+     *        CUMIPMT(rate,nper,pv,start,end[,type])
+     *
+     * @param mixed $rate The Interest rate
+     * @param mixed $periods The total number of payment periods
+     * @param mixed $presentValue Present Value
+     * @param mixed $start The first period in the calculation.
+     *                       Payment periods are numbered beginning with 1.
+     * @param mixed $end the last period in the calculation
+     * @param mixed $type A number 0 or 1 and indicates when payments are due:
+     *                    0 or omitted    At the end of the period.
+     *                    1               At the beginning of the period.
+     */
+    public static function interest(
+        mixed $rate,
+        mixed $periods,
+        mixed $presentValue,
+        mixed $start,
+        mixed $end,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ): string|float|int {
+        $rate = Functions::flattenSingleValue($rate);
+        $periods = Functions::flattenSingleValue($periods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $start = Functions::flattenSingleValue($start);
+        $end = Functions::flattenSingleValue($end);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $periods = CashFlowValidations::validateInt($periods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $start = CashFlowValidations::validateInt($start);
+            $end = CashFlowValidations::validateInt($end);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($start < 1 || $start > $end) {
+            return ExcelError::NAN();
+        }
+
+        // Calculate
+        $interest = 0;
+        for ($per = $start; $per <= $end; ++$per) {
+            $ipmt = Interest::payment($rate, $per, $periods, $presentValue, 0, $type);
+            if (is_string($ipmt)) {
+                return $ipmt;
+            }
+
+            $interest += $ipmt;
+        }
+
+        return $interest;
+    }
+
+    /**
+     * CUMPRINC.
+     *
+     * Returns the cumulative principal paid on a loan between the start and end periods.
+     *
+     * Excel Function:
+     *        CUMPRINC(rate,nper,pv,start,end[,type])
+     *
+     * @param mixed $rate The Interest rate
+     * @param mixed $periods The total number of payment periods as an integer
+     * @param mixed $presentValue Present Value
+     * @param mixed $start The first period in the calculation.
+     *                       Payment periods are numbered beginning with 1.
+     * @param mixed $end the last period in the calculation
+     * @param mixed $type A number 0 or 1 and indicates when payments are due:
+     *                    0 or omitted    At the end of the period.
+     *                    1               At the beginning of the period.
+     */
+    public static function principal(
+        mixed $rate,
+        mixed $periods,
+        mixed $presentValue,
+        mixed $start,
+        mixed $end,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ): string|float|int {
+        $rate = Functions::flattenSingleValue($rate);
+        $periods = Functions::flattenSingleValue($periods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $start = Functions::flattenSingleValue($start);
+        $end = Functions::flattenSingleValue($end);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $periods = CashFlowValidations::validateInt($periods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $start = CashFlowValidations::validateInt($start);
+            $end = CashFlowValidations::validateInt($end);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($start < 1 || $start > $end) {
+            return ExcelError::VALUE();
+        }
+
+        // Calculate
+        $principal = 0;
+        for ($per = $start; $per <= $end; ++$per) {
+            $ppmt = Payments::interestPayment($rate, $per, $periods, $presentValue, 0, $type);
+            if (is_string($ppmt)) {
+                return $ppmt;
+            }
+
+            $principal += $ppmt;
+        }
+
+        return $principal;
+    }
+}

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic/Interest.php

@@ -0,0 +1,213 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant\Periodic;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\CashFlowValidations;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
+
+class Interest
+{
+    private const FINANCIAL_MAX_ITERATIONS = 128;
+
+    private const FINANCIAL_PRECISION = 1.0e-08;
+
+    /**
+     * IPMT.
+     *
+     * Returns the interest payment for a given period for an investment based on periodic, constant payments
+     *         and a constant interest rate.
+     *
+     * Excel Function:
+     *        IPMT(rate,per,nper,pv[,fv][,type])
+     *
+     * @param mixed $interestRate Interest rate per period
+     * @param mixed $period Period for which we want to find the interest
+     * @param mixed $numberOfPeriods Number of periods
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     */
+    public static function payment(
+        mixed $interestRate,
+        mixed $period,
+        mixed $numberOfPeriods,
+        mixed $presentValue,
+        mixed $futureValue = 0,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ): string|float {
+        $interestRate = Functions::flattenSingleValue($interestRate);
+        $period = Functions::flattenSingleValue($period);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $interestRate = CashFlowValidations::validateRate($interestRate);
+            $period = CashFlowValidations::validateInt($period);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($period <= 0 || $period > $numberOfPeriods) {
+            return ExcelError::NAN();
+        }
+
+        // Calculate
+        $interestAndPrincipal = new InterestAndPrincipal(
+            $interestRate,
+            $period,
+            $numberOfPeriods,
+            $presentValue,
+            $futureValue,
+            $type
+        );
+
+        return $interestAndPrincipal->interest();
+    }
+
+    /**
+     * ISPMT.
+     *
+     * Returns the interest payment for an investment based on an interest rate and a constant payment schedule.
+     *
+     * Excel Function:
+     *     =ISPMT(interest_rate, period, number_payments, pv)
+     *
+     * @param mixed $interestRate is the interest rate for the investment
+     * @param mixed $period is the period to calculate the interest rate.  It must be betweeen 1 and number_payments.
+     * @param mixed $numberOfPeriods is the number of payments for the annuity
+     * @param mixed $principleRemaining is the loan amount or present value of the payments
+     */
+    public static function schedulePayment(mixed $interestRate, mixed $period, mixed $numberOfPeriods, mixed $principleRemaining): string|float
+    {
+        $interestRate = Functions::flattenSingleValue($interestRate);
+        $period = Functions::flattenSingleValue($period);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $principleRemaining = Functions::flattenSingleValue($principleRemaining);
+
+        try {
+            $interestRate = CashFlowValidations::validateRate($interestRate);
+            $period = CashFlowValidations::validateInt($period);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $principleRemaining = CashFlowValidations::validateFloat($principleRemaining);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($period <= 0 || $period > $numberOfPeriods) {
+            return ExcelError::NAN();
+        }
+
+        // Return value
+        $returnValue = 0;
+
+        // Calculate
+        $principlePayment = ($principleRemaining * 1.0) / ($numberOfPeriods * 1.0);
+        for ($i = 0; $i <= $period; ++$i) {
+            $returnValue = $interestRate * $principleRemaining * -1;
+            $principleRemaining -= $principlePayment;
+            // principle needs to be 0 after the last payment, don't let floating point screw it up
+            if ($i == $numberOfPeriods) {
+                $returnValue = 0.0;
+            }
+        }
+
+        return $returnValue;
+    }
+
+    /**
+     * RATE.
+     *
+     * Returns the interest rate per period of an annuity.
+     * RATE is calculated by iteration and can have zero or more solutions.
+     * If the successive results of RATE do not converge to within 0.0000001 after 20 iterations,
+     * RATE returns the #NUM! error value.
+     *
+     * Excel Function:
+     *        RATE(nper,pmt,pv[,fv[,type[,guess]]])
+     *
+     * @param mixed $numberOfPeriods The total number of payment periods in an annuity
+     * @param mixed $payment The payment made each period and cannot change over the life of the annuity.
+     *                           Typically, pmt includes principal and interest but no other fees or taxes.
+     * @param mixed $presentValue The present value - the total amount that a series of future payments is worth now
+     * @param mixed $futureValue The future value, or a cash balance you want to attain after the last payment is made.
+     *                               If fv is omitted, it is assumed to be 0 (the future value of a loan,
+     *                               for example, is 0).
+     * @param mixed $type A number 0 or 1 and indicates when payments are due:
+     *                      0 or omitted    At the end of the period.
+     *                      1               At the beginning of the period.
+     * @param mixed $guess Your guess for what the rate will be.
+     *                          If you omit guess, it is assumed to be 10 percent.
+     */
+    public static function rate(
+        mixed $numberOfPeriods,
+        mixed $payment,
+        mixed $presentValue,
+        mixed $futureValue = 0.0,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD,
+        mixed $guess = 0.1
+    ): string|float {
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $payment = Functions::flattenSingleValue($payment);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+        $guess = ($guess === null) ? 0.1 : Functions::flattenSingleValue($guess);
+
+        try {
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $payment = CashFlowValidations::validateFloat($payment);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+            $guess = CashFlowValidations::validateFloat($guess);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $rate = $guess;
+        // rest of code adapted from python/numpy
+        $close = false;
+        $iter = 0;
+        while (!$close && $iter < self::FINANCIAL_MAX_ITERATIONS) {
+            $nextdiff = self::rateNextGuess($rate, $numberOfPeriods, $payment, $presentValue, $futureValue, $type);
+            if (!is_numeric($nextdiff)) {
+                break;
+            }
+            $rate1 = $rate - $nextdiff;
+            $close = abs($rate1 - $rate) < self::FINANCIAL_PRECISION;
+            ++$iter;
+            $rate = $rate1;
+        }
+
+        return $close ? $rate : ExcelError::NAN();
+    }
+
+    private static function rateNextGuess(float $rate, int $numberOfPeriods, float $payment, float $presentValue, float $futureValue, int $type): string|float
+    {
+        if ($rate == 0.0) {
+            return ExcelError::NAN();
+        }
+        $tt1 = ($rate + 1) ** $numberOfPeriods;
+        $tt2 = ($rate + 1) ** ($numberOfPeriods - 1);
+        $numerator = $futureValue + $tt1 * $presentValue + $payment * ($tt1 - 1) * ($rate * $type + 1) / $rate;
+        $denominator = $numberOfPeriods * $tt2 * $presentValue - $payment * ($tt1 - 1)
+            * ($rate * $type + 1) / ($rate * $rate) + $numberOfPeriods
+            * $payment * $tt2 * ($rate * $type + 1) / $rate + $payment * ($tt1 - 1) * $type / $rate;
+        if ($denominator == 0) {
+            return ExcelError::NAN();
+        }
+
+        return $numerator / $denominator;
+    }
+}

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic/InterestAndPrincipal.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant\Periodic;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+
+class InterestAndPrincipal
+{
+    protected float $interest;
+
+    protected float $principal;
+
+    public function __construct(
+        float $rate = 0.0,
+        int $period = 0,
+        int $numberOfPeriods = 0,
+        float $presentValue = 0,
+        float $futureValue = 0,
+        int $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $payment = Payments::annuity($rate, $numberOfPeriods, $presentValue, $futureValue, $type);
+        $capital = $presentValue;
+        $interest = 0.0;
+        $principal = 0.0;
+        for ($i = 1; $i <= $period; ++$i) {
+            $interest = ($type === FinancialConstants::PAYMENT_BEGINNING_OF_PERIOD && $i == 1) ? 0 : -$capital * $rate;
+            $principal = (float) $payment - $interest;
+            $capital += $principal;
+        }
+
+        $this->interest = $interest;
+        $this->principal = $principal;
+    }
+
+    public function interest(): float
+    {
+        return $this->interest;
+    }
+
+    public function principal(): float
+    {
+        return $this->principal;
+    }
+}

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic/Payments.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant\Periodic;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\CashFlowValidations;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
+
+class Payments
+{
+    /**
+     * PMT.
+     *
+     * Returns the constant payment (annuity) for a cash flow with a constant interest rate.
+     *
+     * @param mixed $interestRate Interest rate per period
+     * @param mixed $numberOfPeriods Number of periods
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function annuity(
+        mixed $interestRate,
+        mixed $numberOfPeriods,
+        mixed $presentValue,
+        mixed $futureValue = 0,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ): string|float {
+        $interestRate = Functions::flattenSingleValue($interestRate);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $interestRate = CashFlowValidations::validateRate($interestRate);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Calculate
+        if ($interestRate != 0.0) {
+            return (-$futureValue - $presentValue * (1 + $interestRate) ** $numberOfPeriods)
+                / (1 + $interestRate * $type) / (((1 + $interestRate) ** $numberOfPeriods - 1) / $interestRate);
+        }
+
+        return (-$presentValue - $futureValue) / $numberOfPeriods;
+    }
+
+    /**
+     * PPMT.
+     *
+     * Returns the interest payment for a given period for an investment based on periodic, constant payments
+     *         and a constant interest rate.
+     *
+     * @param mixed $interestRate Interest rate per period
+     * @param mixed $period Period for which we want to find the interest
+     * @param mixed $numberOfPeriods Number of periods
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function interestPayment(
+        mixed $interestRate,
+        mixed $period,
+        mixed $numberOfPeriods,
+        mixed $presentValue,
+        mixed $futureValue = 0,
+        mixed $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ): string|float {
+        $interestRate = Functions::flattenSingleValue($interestRate);
+        $period = Functions::flattenSingleValue($period);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $interestRate = CashFlowValidations::validateRate($interestRate);
+            $period = CashFlowValidations::validateInt($period);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($period <= 0 || $period > $numberOfPeriods) {
+            return ExcelError::NAN();
+        }
+
+        // Calculate
+        $interestAndPrincipal = new InterestAndPrincipal(
+            $interestRate,
+            $period,
+            $numberOfPeriods,
+            $presentValue,
+            $futureValue,
+            $type
+        );
+
+        return $interestAndPrincipal->principal();
+    }
+}

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/Single.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
+
+class Single
+{
+    /**
+     * FVSCHEDULE.
+     *
+     * Returns the future value of an initial principal after applying a series of compound interest rates.
+     * Use FVSCHEDULE to calculate the future value of an investment with a variable or adjustable rate.
+     *
+     * Excel Function:
+     *        FVSCHEDULE(principal,schedule)
+     *
+     * @param mixed $principal the present value
+     * @param float[] $schedule an array of interest rates to apply
+     */
+    public static function futureValue(mixed $principal, array $schedule): string|float
+    {
+        $principal = Functions::flattenSingleValue($principal);
+        $schedule = Functions::flattenArray($schedule);
+
+        try {
+            $principal = CashFlowValidations::validateFloat($principal);
+
+            foreach ($schedule as $rate) {
+                $rate = CashFlowValidations::validateFloat($rate);
+                $principal *= 1 + $rate;
+            }
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return $principal;
+    }
+
+    /**
+     * PDURATION.
+     *
+     * Calculates the number of periods required for an investment to reach a specified value.
+     *
+     * @param mixed $rate Interest rate per period
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function periods(mixed $rate, mixed $presentValue, mixed $futureValue): string|float
+    {
+        $rate = Functions::flattenSingleValue($rate);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = Functions::flattenSingleValue($futureValue);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($rate <= 0.0 || $presentValue <= 0.0 || $futureValue <= 0.0) {
+            return ExcelError::NAN();
+        }
+
+        return (log($futureValue) - log($presentValue)) / log(1 + $rate);
+    }
+
+    /**
+     * RRI.
+     *
+     * Calculates the interest rate required for an investment to grow to a specified future value .
+     *
+     * @param array|float $periods The number of periods over which the investment is made
+     * @param array|float $presentValue Present Value
+     * @param array|float $futureValue Future Value
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function interestRate(array|float $periods = 0.0, array|float $presentValue = 0.0, array|float $futureValue = 0.0): string|float
+    {
+        $periods = Functions::flattenSingleValue($periods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = Functions::flattenSingleValue($futureValue);
+
+        try {
+            $periods = CashFlowValidations::validateFloat($periods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($periods <= 0.0 || $presentValue <= 0.0 || $futureValue < 0.0) {
+            return ExcelError::NAN();
+        }
+
+        return ($futureValue / $presentValue) ** (1 / $periods) - 1;
+    }
+}

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/Variable/NonPeriodic.php

@@ -0,0 +1,301 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Variable;
+
+use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
+
+class NonPeriodic
+{
+    const FINANCIAL_MAX_ITERATIONS = 128;
+
+    const FINANCIAL_PRECISION = 1.0e-08;
+
+    const DEFAULT_GUESS = 0.1;
+
+    /**
+     * XIRR.
+     *
+     * Returns the internal rate of return for a schedule of cash flows that is not necessarily periodic.
+     *
+     * Excel Function:
+     *        =XIRR(values,dates,guess)
+     *
+     * @param float[] $values     A series of cash flow payments
+     *                                The series of values must contain at least one positive value & one negative value
+     * @param mixed[] $dates      A series of payment dates
+     *                                The first payment date indicates the beginning of the schedule of payments
+     *                                All other dates must be later than this date, but they may occur in any order
+     * @param mixed $guess        An optional guess at the expected answer
+     */
+    public static function rate(array $values, array $dates, mixed $guess = self::DEFAULT_GUESS): float|string
+    {
+        $rslt = self::xirrPart1($values, $dates);
+        if ($rslt !== '') {
+            return $rslt;
+        }
+
+        // create an initial range, with a root somewhere between 0 and guess
+        $guess = Functions::flattenSingleValue($guess) ?? self::DEFAULT_GUESS;
+        if (!is_numeric($guess)) {
+            return ExcelError::VALUE();
+        }
+        $guess = ($guess + 0.0) ?: self::DEFAULT_GUESS;
+        $x1 = 0.0;
+        $x2 = $guess + 0.0;
+        $f1 = self::xnpvOrdered($x1, $values, $dates, false);
+        $f2 = self::xnpvOrdered($x2, $values, $dates, false);
+        $found = false;
+        for ($i = 0; $i < self::FINANCIAL_MAX_ITERATIONS; ++$i) {
+            if (!is_numeric($f1)) {
+                return $f1;
+            }
+            if (!is_numeric($f2)) {
+                return $f2;
+            }
+            $f1 = (float) $f1;
+            $f2 = (float) $f2;
+            if (($f1 * $f2) < 0.0) {
+                $found = true;
+
+                break;
+            } elseif (abs($f1) < abs($f2)) {
+                $x1 += 1.6 * ($x1 - $x2);
+                $f1 = self::xnpvOrdered($x1, $values, $dates, false);
+            } else {
+                $x2 += 1.6 * ($x2 - $x1);
+                $f2 = self::xnpvOrdered($x2, $values, $dates, false);
+            }
+        }
+        if ($found) {
+            return self::xirrPart3($values, $dates, $x1, $x2);
+        }
+
+        // Newton-Raphson didn't work - try bisection
+        $x1 = $guess - 0.5;
+        $x2 = $guess + 0.5;
+        for ($i = 0; $i < self::FINANCIAL_MAX_ITERATIONS; ++$i) {
+            $f1 = self::xnpvOrdered($x1, $values, $dates, false, true);
+            $f2 = self::xnpvOrdered($x2, $values, $dates, false, true);
+            if (!is_numeric($f1) || !is_numeric($f2)) {
+                break;
+            }
+            if ($f1 * $f2 <= 0) {
+                $found = true;
+
+                break;
+            }
+            $x1 -= 0.5;
+            $x2 += 0.5;
+        }
+        if ($found) {
+            return self::xirrBisection($values, $dates, $x1, $x2);
+        }
+
+        return ExcelError::NAN();
+    }
+
+    /**
+     * XNPV.
+     *
+     * Returns the net present value for a schedule of cash flows that is not necessarily periodic.
+     * To calculate the net present value for a series of cash flows that is periodic, use the NPV function.
+     *
+     * Excel Function:
+     *        =XNPV(rate,values,dates)
+     *
+     * @param array|float $rate the discount rate to apply to the cash flows
+     * @param float[] $values A series of cash flows that corresponds to a schedule of payments in dates.
+     *                          The first payment is optional and corresponds to a cost or payment that occurs
+     *                              at the beginning of the investment.
+     *                          If the first value is a cost or payment, it must be a negative value.
+     *                             All succeeding payments are discounted based on a 365-day year.
+     *                          The series of values must contain at least one positive value and one negative value.
+     * @param mixed[] $dates A schedule of payment dates that corresponds to the cash flow payments.
+     *                         The first payment date indicates the beginning of the schedule of payments.
+     *                         All other dates must be later than this date, but they may occur in any order.
+     */
+    public static function presentValue(array|float $rate, array $values, array $dates): float|string
+    {
+        return self::xnpvOrdered($rate, $values, $dates, true);
+    }
+
+    private static function bothNegAndPos(bool $neg, bool $pos): bool
+    {
+        return $neg && $pos;
+    }
+
+    private static function xirrPart1(mixed &$values, mixed &$dates): string
+    {
+        $values = Functions::flattenArray($values);
+        $dates = Functions::flattenArray($dates);
+        $valuesIsArray = count($values) > 1;
+        $datesIsArray = count($dates) > 1;
+        if (!$valuesIsArray && !$datesIsArray) {
+            return ExcelError::NA();
+        }
+        if (count($values) != count($dates)) {
+            return ExcelError::NAN();
+        }
+
+        $datesCount = count($dates);
+        for ($i = 0; $i < $datesCount; ++$i) {
+            try {
+                $dates[$i] = DateTimeExcel\Helpers::getDateValue($dates[$i]);
+            } catch (Exception $e) {
+                return $e->getMessage();
+            }
+        }
+
+        return self::xirrPart2($values);
+    }
+
+    private static function xirrPart2(array &$values): string
+    {
+        $valCount = count($values);
+        $foundpos = false;
+        $foundneg = false;
+        for ($i = 0; $i < $valCount; ++$i) {
+            $fld = $values[$i];
+            if (!is_numeric($fld)) {
+                return ExcelError::VALUE();
+            } elseif ($fld > 0) {
+                $foundpos = true;
+            } elseif ($fld < 0) {
+                $foundneg = true;
+            }
+        }
+        if (!self::bothNegAndPos($foundneg, $foundpos)) {
+            return ExcelError::NAN();
+        }
+
+        return '';
+    }
+
+    private static function xirrPart3(array $values, array $dates, float $x1, float $x2): float|string
+    {
+        $f = self::xnpvOrdered($x1, $values, $dates, false);
+        if ($f < 0.0) {
+            $rtb = $x1;
+            $dx = $x2 - $x1;
+        } else {
+            $rtb = $x2;
+            $dx = $x1 - $x2;
+        }
+
+        $rslt = ExcelError::VALUE();
+        for ($i = 0; $i < self::FINANCIAL_MAX_ITERATIONS; ++$i) {
+            $dx *= 0.5;
+            $x_mid = $rtb + $dx;
+            $f_mid = (float) self::xnpvOrdered($x_mid, $values, $dates, false);
+            if ($f_mid <= 0.0) {
+                $rtb = $x_mid;
+            }
+            if ((abs($f_mid) < self::FINANCIAL_PRECISION) || (abs($dx) < self::FINANCIAL_PRECISION)) {
+                $rslt = $x_mid;
+
+                break;
+            }
+        }
+
+        return $rslt;
+    }
+
+    private static function xirrBisection(array $values, array $dates, float $x1, float $x2): string|float
+    {
+        $rslt = ExcelError::NAN();
+        for ($i = 0; $i < self::FINANCIAL_MAX_ITERATIONS; ++$i) {
+            $rslt = ExcelError::NAN();
+            $f1 = self::xnpvOrdered($x1, $values, $dates, false, true);
+            $f2 = self::xnpvOrdered($x2, $values, $dates, false, true);
+            if (!is_numeric($f1) || !is_numeric($f2)) {
+                break;
+            }
+            $f1 = (float) $f1;
+            $f2 = (float) $f2;
+            if (abs($f1) < self::FINANCIAL_PRECISION && abs($f2) < self::FINANCIAL_PRECISION) {
+                break;
+            }
+            if ($f1 * $f2 > 0) {
+                break;
+            }
+            $rslt = ($x1 + $x2) / 2;
+            $f3 = self::xnpvOrdered($rslt, $values, $dates, false, true);
+            if (!is_float($f3)) {
+                break;
+            }
+            if ($f3 * $f1 < 0) {
+                $x2 = $rslt;
+            } else {
+                $x1 = $rslt;
+            }
+            if (abs($f3) < self::FINANCIAL_PRECISION) {
+                break;
+            }
+        }
+
+        return $rslt;
+    }
+
+    private static function xnpvOrdered(mixed $rate, mixed $values, mixed $dates, bool $ordered = true, bool $capAtNegative1 = false): float|string
+    {
+        $rate = Functions::flattenSingleValue($rate);
+        $values = Functions::flattenArray($values);
+        $dates = Functions::flattenArray($dates);
+        $valCount = count($values);
+
+        try {
+            self::validateXnpv($rate, $values, $dates);
+            if ($capAtNegative1 && $rate <= -1) {
+                $rate = -1.0 + 1.0E-10;
+            }
+            $date0 = DateTimeExcel\Helpers::getDateValue($dates[0]);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $xnpv = 0.0;
+        for ($i = 0; $i < $valCount; ++$i) {
+            if (!is_numeric($values[$i])) {
+                return ExcelError::VALUE();
+            }
+
+            try {
+                $datei = DateTimeExcel\Helpers::getDateValue($dates[$i]);
+            } catch (Exception $e) {
+                return $e->getMessage();
+            }
+            if ($date0 > $datei) {
+                $dif = $ordered ? ExcelError::NAN() : -((int) DateTimeExcel\Difference::interval($datei, $date0, 'd'));
+            } else {
+                $dif = Functions::scalar(DateTimeExcel\Difference::interval($date0, $datei, 'd'));
+            }
+            if (!is_numeric($dif)) {
+                return $dif;
+            }
+            if ($rate <= -1.0) {
+                $xnpv += -abs($values[$i]) / (-1 - $rate) ** ($dif / 365);
+            } else {
+                $xnpv += $values[$i] / (1 + $rate) ** ($dif / 365);
+            }
+        }
+
+        return is_finite($xnpv) ? $xnpv : ExcelError::VALUE();
+    }
+
+    private static function validateXnpv(mixed $rate, array $values, array $dates): void
+    {
+        if (!is_numeric($rate)) {
+            throw new Exception(ExcelError::VALUE());
+        }
+        $valCount = count($values);
+        if ($valCount != count($dates)) {
+            throw new Exception(ExcelError::NAN());
+        }
+        if ($valCount > 1 && ((min($values) > 0) || (max($values) < 0))) {
+            throw new Exception(ExcelError::NAN());
+        }
+    }
+}

lib/PhpSpreadsheet/Calculation/Financial/CashFlow/Variable/Periodic.php

@@ -0,0 +1,157 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Variable;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
+
+class Periodic
+{
+    const FINANCIAL_MAX_ITERATIONS = 128;
+
+    const FINANCIAL_PRECISION = 1.0e-08;
+
+    /**
+     * IRR.
+     *
+     * Returns the internal rate of return for a series of cash flows represented by the numbers in values.
+     * These cash flows do not have to be even, as they would be for an annuity. However, the cash flows must occur
+     * at regular intervals, such as monthly or annually. The internal rate of return is the interest rate received
+     * for an investment consisting of payments (negative values) and income (positive values) that occur at regular
+     * periods.
+     *
+     * Excel Function:
+     *        IRR(values[,guess])
+     *
+     * @param mixed $values An array or a reference to cells that contain numbers for which you want
+     *                                    to calculate the internal rate of return.
+     *                                Values must contain at least one positive value and one negative value to
+     *                                    calculate the internal rate of return.
+     * @param mixed $guess A number that you guess is close to the result of IRR
+     */
+    public static function rate(mixed $values, mixed $guess = 0.1): string|float
+    {
+        if (!is_array($values)) {
+            return ExcelError::VALUE();
+        }
+        $values = Functions::flattenArray($values);
+        $guess = Functions::flattenSingleValue($guess);
+
+        // create an initial range, with a root somewhere between 0 and guess
+        $x1 = 0.0;
+        $x2 = $guess;
+        $f1 = self::presentValue($x1, $values);
+        $f2 = self::presentValue($x2, $values);
+        for ($i = 0; $i < self::FINANCIAL_MAX_ITERATIONS; ++$i) {
+            if (($f1 * $f2) < 0.0) {
+                break;
+            }
+            if (abs($f1) < abs($f2)) {
+                $f1 = self::presentValue($x1 += 1.6 * ($x1 - $x2), $values);
+            } else {
+                $f2 = self::presentValue($x2 += 1.6 * ($x2 - $x1), $values);
+            }
+        }
+        if (($f1 * $f2) > 0.0) {
+            return ExcelError::VALUE();
+        }
+
+        $f = self::presentValue($x1, $values);
+        if ($f < 0.0) {
+            $rtb = $x1;
+            $dx = $x2 - $x1;
+        } else {
+            $rtb = $x2;
+            $dx = $x1 - $x2;
+        }
+
+        for ($i = 0; $i < self::FINANCIAL_MAX_ITERATIONS; ++$i) {
+            $dx *= 0.5;
+            $x_mid = $rtb + $dx;
+            $f_mid = self::presentValue($x_mid, $values);
+            if ($f_mid <= 0.0) {
+                $rtb = $x_mid;
+            }
+            if ((abs($f_mid) < self::FINANCIAL_PRECISION) || (abs($dx) < self::FINANCIAL_PRECISION)) {
+                return $x_mid;
+            }
+        }
+
+        return ExcelError::VALUE();
+    }
+
+    /**
+     * MIRR.
+     *
+     * Returns the modified internal rate of return for a series of periodic cash flows. MIRR considers both
+     *        the cost of the investment and the interest received on reinvestment of cash.
+     *
+     * Excel Function:
+     *        MIRR(values,finance_rate, reinvestment_rate)
+     *
+     * @param mixed $values An array or a reference to cells that contain a series of payments and
+     *                         income occurring at regular intervals.
+     *                      Payments are negative value, income is positive values.
+     * @param mixed $financeRate The interest rate you pay on the money used in the cash flows
+     * @param mixed $reinvestmentRate The interest rate you receive on the cash flows as you reinvest them
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function modifiedRate(mixed $values, mixed $financeRate, mixed $reinvestmentRate): string|float
+    {
+        if (!is_array($values)) {
+            return ExcelError::DIV0();
+        }
+        $values = Functions::flattenArray($values);
+        $financeRate = Functions::flattenSingleValue($financeRate);
+        $reinvestmentRate = Functions::flattenSingleValue($reinvestmentRate);
+        $n = count($values);
+
+        $rr = 1.0 + $reinvestmentRate;
+        $fr = 1.0 + $financeRate;
+
+        $npvPos = $npvNeg = 0.0;
+        foreach ($values as $i => $v) {
+            if ($v >= 0) {
+                $npvPos += $v / $rr ** $i;
+            } else {
+                $npvNeg += $v / $fr ** $i;
+            }
+        }
+
+        if ($npvNeg === 0.0 || $npvPos === 0.0) {
+            return ExcelError::DIV0();
+        }
+
+        $mirr = ((-$npvPos * $rr ** $n)
+                / ($npvNeg * ($rr))) ** (1.0 / ($n - 1)) - 1.0;
+
+        return is_finite($mirr) ? $mirr : ExcelError::NAN();
+    }
+
+    /**
+     * NPV.
+     *
+     * Returns the Net Present Value of a cash flow series given a discount rate.
+     *
+     * @param array $args
+     */
+    public static function presentValue(mixed $rate, ...$args): int|float
+    {
+        $returnValue = 0;
+
+        $rate = Functions::flattenSingleValue($rate);
+        $aArgs = Functions::flattenArray($args);
+
+        // Calculate
+        $countArgs = count($aArgs);
+        for ($i = 1; $i <= $countArgs; ++$i) {
+            // Is it a numeric value?
+            if (is_numeric($aArgs[$i - 1])) {
+                $returnValue += $aArgs[$i - 1] / (1 + $rate) ** $i;
+            }
+        }
+
+        return $returnValue;
+    }
+}