public void N_IsCalculatedCorrectly(double m, double p, double k0, double e, double kn, double expectedN)
        {
            const double localTolerance = 0.01;
            var          n = FinancialCalculation.N(kn, k0, e, p, m);

            Assert.True(Math.Abs(n - expectedN) < localTolerance);
        }
        public void K0_IsCalculatedCorrectly(double m, double n, double p, double e, double kn, double expectedK0)
        {
            const double localTolerance = 0.01;
            var          k0             = FinancialCalculation.K0(kn, e, p, n, m);

            Assert.True(Math.Abs(k0 - expectedK0) < localTolerance);
        }
        public void E_IsCalculatedCorrectly(bool advance, double m, double n, double p, double k0, double kn, double expectedE)
        {
            const double localTolerance = 0.01;
            var          e = FinancialCalculation.E(kn, k0, p, n, m, advance);

            Assert.True(Math.Abs(e - expectedE) < localTolerance);
        }
        [InlineData(12, 5.3660387, -10000, -550, 1000000, 39.78)] //        --+
        public void NAdvance_IsCalculatedCorrectly_PermutationOfRealNumbers(double m, double p, double k0, double e, double kn, double expectedN)
        {
            const double localTolerance = 0.01;
            var          n = FinancialCalculation.N(kn, k0, e, p, m, true);

            Assert.True(Math.Abs(n - expectedN) < localTolerance);
        }
        public void Kn_IsCalculatedCorrectly(double m, double n, double p, double k0, double e, double expectedKn)
        {
            const double localTolerance = 0.01;
            var          finalCapital   = FinancialCalculation.Kn(k0, e, p, n, m);

            Assert.True(Math.Abs(finalCapital - expectedKn) < localTolerance);
        }
        public void P_IsCalculatedCorrectly(double m, double n, double k0, double e, double kn, double expectedP)
        {
            kn *= -1;
            const double localTolerance = 0.001;
            var          pNom           = FinancialCalculation.P(kn, k0, e, n, m);
            var          pEff           = FinancialCalculation.GetEffectiveInterestRate(pNom, m);

            Assert.True(Math.Abs(pEff - expectedP) < localTolerance);
        }
        public void RepaymentRateIsCalculatedCorrectly(double m, double k0, double p, double e, double expectedRepaymentRate)
        {
            var repaymentRate = FinancialCalculation.GetRepaymentRate(k0, p, m, e);

            Assert.Equal(repaymentRate, expectedRepaymentRate);
        }
        public void AnnuityIsCalculatedCorrectly(double m, double k0, double p, double repaymentRate, double expectedE)
        {
            var annuity = FinancialCalculation.GetAnnuity(k0, repaymentRate, p, m);

            Assert.Equal(annuity, expectedE);
        }
        [InlineData(12, 5.3660387, -10000, -550, -1000000)] //      ---
        public void NAdvance_IsCalculatedCorrectly_PermutationOfNan(double m, double p, double k0, double e, double kn)
        {
            var n = FinancialCalculation.N(kn, k0, e, p, m);

            Assert.True(double.IsNaN(n));
        }
        public void YearlyNominalInterestRateIsCalculatedCorrectly(double m, double effectiveInterestRate, double expectedP)
        {
            var p = FinancialCalculation.GetYearlyNominalInterestRate(m, effectiveInterestRate);

            Assert.Equal(Math.Round(p, 3), expectedP);
        }
        public void EffectiveInterestRateIsCalculatedCorrectly(double m, double p, double expectedEffectiveInterestRate)
        {
            var effectiveInterestRate = FinancialCalculation.GetEffectiveInterestRate(p, m);

            Assert.Equal(Math.Round(effectiveInterestRate, 3), expectedEffectiveInterestRate);
        }