financialtests.cs

大名鼎鼎的mono是.NET平台的跨平台（支持linux

			Assert.AreEqual (0.16479098450893415, Financial.IRR (ref values, 0.5), "A3");

			values = new double[] {-100000, 40000, 35000, 30000, 25000};

			Assert.AreEqual (0.124414495406241, Financial.IRR (ref values, 0.1), "A4");

			Assert.AreEqual (0.124414495415021, Financial.IRR (ref values, 0.3), "A5");

			Assert.AreEqual (0.124414495410257, Financial.IRR (ref values, 0.5), "A6");
		}
#endif

		[Category ("NotWorking")]//Not Implemented
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void IRR_2()
		{
			//Arguments are not valid.
			double[] values = new double[] {-500000, 20, 20, 20, 10000};

			Financial.IRR(ref values, 10000);
		}

		[Category ("NotWorking")]//Not Implemented
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void IRR_3()
		{
			//Arguments are not valid.
			double[] values = new double[] {100, 20, 30, 30, 30};

			Financial.IRR(ref values, 0.1);
		}

		#endregion

		#region MIRR Tests

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void MIRRArgs1()
		{
			double [] arr = new double [] {-70000, 22000, 25000, 28000, 31000};
			double d = Financial.MIRR(ref arr, -1, 1);
		}
		
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void MIRRArgs2()
		{
			double [] arr = new double [] {-70000, 22000, 25000, 28000, 31000};
			double d = Financial.MIRR(ref arr, 1, -1);
		}
		
		[Test]
		public void MIRR()
		{
			double [] arr = new double [] {-70000, 22000, 25000, 28000, 31000};
			double d = Financial.MIRR (ref arr, 1, 1);
			Assert.AreEqual(0.509044845533018, d, 0.00001, "#MIRR01");
			
			arr = new double [] {-70000, 22000, 25000, 28000, 31000};
			d = Financial.MIRR (ref arr, 5, 5);
			Assert.AreEqual(2.02366041666348, d, 0.00001, "#MIRR02");
		}

		[Test]
		public void MIRR_1()
		{
			double[] values = new double[] {-50000, 20000, 20000, 20000, 10000};

			Assert.AreEqual(0.14382317535283296, Financial.MIRR(ref values, 0.1, 0.12), 1E-10);

			Assert.AreEqual(0.32152371134887248, Financial.MIRR(ref values, 0.3, 0.5), 1E-10);

			Assert.AreEqual(0.41431961645993387, Financial.MIRR(ref values, 0.5, 0.7), 1E-10);

			values = new double[] {-100000, 40000, 35000, 30000, 25000};

			Assert.AreEqual(0.12239312521886214, Financial.MIRR(ref values, 0.1, 0.12), 1E-10);

			Assert.AreEqual(0.29787828889780776, Financial.MIRR(ref values, 0.3, 0.5), 1E-10);

			Assert.AreEqual(0.39034333083777972, Financial.MIRR(ref values, 0.5, 0.7), 1E-10);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void MIRR_2()
		{
			// Argument 'FinanceRate' is not a valid value.
			double[] values = new double[] {-50000, 20000, 20000, 20000, 10000};

			Financial.MIRR(ref values, -1, 0.12);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void MIRR_3()
		{
			// Argument 'ReinvestRate' is not a valid value.
			double[] values = new double[] {-50000, 20000, 20000, 20000, 10000};

			Financial.MIRR(ref values, 0.1, -1);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void MIRR_4()
		{
			// Argument 'ReinvestRate' is not a valid value.
			double[] values = new double[] {-50000, 20000, 20000, 20000, 10000};

			Financial.MIRR(ref values, 0.1, -3);
		}

		[Test]
		[ExpectedException(typeof(System.NullReferenceException))]
		public void MIRR_5()
		{
			double[] values = null;

			Financial.MIRR(ref values, 0.1, 0.12);
		}

		[Category ("NotWorking")]
		[Category ("TargetJvmNotWorking")]
		[Test]
		[ExpectedException(typeof(DivideByZeroException))]
		public void MIRR_6()
		{
			double[] values = new double[] {100, 20, 30, 30, 30};

			Financial.MIRR(ref values, 0.1, 0.1);
		}

		#endregion

		#region NPer Tests

		
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPerArgs1()
		{
			double d = Financial.NPer (-1, 2, 2, 2, DueDate.BegOfPeriod);
		}
		
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPerArgs2()
		{
			double d = Financial.NPer (0, 0, 2, 2, DueDate.BegOfPeriod);
		}
		
		[Test]
		public void NPer()
		{
			double d = Financial.NPer (3, 4, 6, 2, DueDate.BegOfPeriod);
			Assert.AreEqual(-0.882767373181489, d, 0.0000001,  "#NPer01");
			
			d = Financial.NPer (1, -4, -6, -2, DueDate.EndOfPeriod);
			Assert.AreEqual(-2.32192809488736, d, 0.0000001, "#NPer02");
		}
		
		[Test]
		public void NPer_1()
		{
			Assert.AreEqual(-47.613161535165531, (Financial.NPer(0.1/48, 200, 10000, 0, DueDate.EndOfPeriod)), 0.00000001);
			Assert.AreEqual(-47.518910769564712, Financial.NPer(0.1/48, 200, 10000, 0, DueDate.BegOfPeriod), 0.00000001);

			Assert.AreEqual(-401.12014892843246, Financial.NPer(0.1/48, 200, 10000, 50000, DueDate.EndOfPeriod), 0.0000001);
			Assert.AreEqual(-399.9412969471162, Financial.NPer(0.1/48, 200, 10000, 50000, DueDate.BegOfPeriod), 0.0000001);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPer_2()
		{
			// Argument 'Rate' is not a valid value.
			Financial.NPer(-1, 200, 10000, 0, DueDate.EndOfPeriod);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPer_3()
		{
			// Argument 'Pmt' is not a valid value.
			Financial.NPer(0, 0, 10000, 0, DueDate.EndOfPeriod);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPer_4()
		{
			// Cannot calculate number of periods using the arguments provided.
			Financial.NPer(0.1/48, 0, 10000, 0, DueDate.EndOfPeriod);
		}

		#endregion

		#region IPmt Tests

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void IPmtArgs1()
		{
			Financial.IPmt (3, 6, 4, 2, 2, DueDate.BegOfPeriod);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void IPmtArgs2()
		{
			Financial.IPmt (3, 0, 4, 2, 2, DueDate.BegOfPeriod);
		}

		[Test]
		public void IPmt()
		{
			double d = Financial.IPmt (10, 2, 3, 7, 9, DueDate.BegOfPeriod);
			Assert.AreEqual ( -6.25427204374573, d, 1E-10, "#IPmt01");
			
			d = Financial.IPmt (10, 4, 4, 7, 4, DueDate.EndOfPeriod);
			Assert.AreEqual ( -60.0068306011053, d, 1E-10 , "#IPmt02");
			
			d = Financial.IPmt (0, 5, 7, 7, 2, DueDate.BegOfPeriod);
			Assert.AreEqual( 0, d, "#IPmt03");
			
			d = Financial.IPmt (1000, 1, 7, 7, 2, DueDate.BegOfPeriod);
			Assert.AreEqual( 0, d, "#IPmt03");
			
			d = Financial.IPmt (-5, 5, 7, -7, -2, DueDate.BegOfPeriod);
			Assert.AreEqual(8.92508391821792, d, 1E-10, "#IPmt04");

		}

		[Test]
		public void IPmt_1()
		{
			Assert.AreEqual(-29.246960945707116, Financial.IPmt(0.1/48, 36, 48, 50000, 0, DueDate.EndOfPeriod), 1E-10);

			Assert.AreEqual(-55.550772957533624, Financial.IPmt(0.1/48, 24, 48, 50000, 0, DueDate.EndOfPeriod), 1E-10);

			Assert.AreEqual(-54.4678461379274, Financial.IPmt(0.1/48, 24.5, 48, 50000, 0, DueDate.EndOfPeriod), 1E-10);

			Assert.AreEqual(-2.2779661153231245, Financial.IPmt(0.1/48, 48, 48, 50000, 0, DueDate.EndOfPeriod), 1E-10);

			Assert.AreEqual(42.6652760279442, Financial.IPmt(0.1/48, 24.3, 48.3, 50000, 100000, DueDate.EndOfPeriod), 1E-9);

			Assert.AreEqual(-29.186156453096753, Financial.IPmt(0.1/48, 36, 48, 50000, 0, DueDate.BegOfPeriod), 1E-10);

			Assert.AreEqual(-55.435282785064992, Financial.IPmt(0.1/48, 24, 48, 50000, 0, DueDate.BegOfPeriod), 1E-10);

			Assert.AreEqual(-54.3546073725681, Financial.IPmt(0.1/48, 24.5, 48, 50000, 0, DueDate.BegOfPeriod), 1E-10);

			Assert.AreEqual(-2.2732302190335001, Financial.IPmt(0.1/48, 48, 48, 50000, 0, DueDate.BegOfPeriod), 1E-10);

			Assert.AreEqual(201.49943498736394, Financial.IPmt(0.1/48, 48, 48, 50000, 100000, DueDate.EndOfPeriod), 1E-9);

			Assert.AreEqual(201.08051724310744, Financial.IPmt(0.1/48, 48, 48, 50000, 100000, DueDate.BegOfPeriod), 1E-9);

			Assert.AreEqual(42.5765748303808, Financial.IPmt(0.1/48, 24.3, 48.3, 50000, 100000, DueDate.BegOfPeriod), 1E-9);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void IPmt_2()
		{
			// Argument 'Per' is not a valid value.
			Financial.IPmt(0.1/48, 56, 48, 50000, 0, DueDate.EndOfPeriod);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void IPmt_3()
		{
			// Argument 'Per' is not a valid value.
			Financial.IPmt(0.1/48, -48, -48, 50000, 0, DueDate.EndOfPeriod);
		}

		#endregion

		#region Pmt Tests

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void PmtArgs()
		{
			Financial.Pmt (1, 0, 1, 1, DueDate.BegOfPeriod);
		}

		[Test]
		public void Pmt()
		{
			double d = Financial.Pmt (2, 5, 2, 3, DueDate.BegOfPeriod);
			Assert.AreEqual (-1.3471074380165289, d, 1E-10, "#Pmt01");
			
			d = Financial.Pmt (2, 5, 2, 3, DueDate.EndOfPeriod);
			Assert.AreEqual (-4.0413223140495864, d, 1E-10, "#Pmt02");
			
			d = Financial.Pmt (-3, -5, -3, -4, DueDate.BegOfPeriod);
			Assert.AreEqual (-5.6818181818181817, d, 1E-10, "#Pmt03");
			
			d = Financial.Pmt (-3, -5, -3, -4, DueDate.EndOfPeriod);
			Assert.AreEqual (11.363636363636363, d, 1E-10, "#Pmt04");
			
			d = Financial.Pmt (0, 1, 0, 0, DueDate.BegOfPeriod);
			Assert.AreEqual ( 0, d, 1E-10, "#Pmt05");
			
			d = Financial.Pmt (0, 1, 0, 0, DueDate.EndOfPeriod);
			Assert.AreEqual ( 0, d, 1E-10, "#Pmt06");
		}

		[Test]
		public void Pmt_1()
		{
			Assert.AreEqual (-1095.7017014703874, Financial.Pmt (0.1 / 48, 48, 50000, 0, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(-1093.4237353550641, Financial.Pmt(0.1/48, 48, 50000, 0, DueDate.BegOfPeriod), 1E-8);

			Assert.AreEqual(-3072.37099816498, Financial.Pmt(0.1/48, 48, 50000, 100000, DueDate.BegOfPeriod), 1E-8);

			Assert.AreEqual(-3027.53768194438, Financial.Pmt(0.1/48, 48.7, 50000, 100000, DueDate.BegOfPeriod), 1E-8);

			Assert.AreEqual(3182.938437744494, Financial.Pmt(0.1/48, -48, 50000, 100000, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(3138.01171878177, Financial.Pmt(0.1/48, -48.7, 50000, 100000, DueDate.EndOfPeriod), 1E-8);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void Pmt_2()
		{
			// Argument 'NPer' is not a valid value.
			Financial.Pmt(0.1/48, 0, 50000, 0, DueDate.EndOfPeriod);
		}

		#endregion

		#region PPmt Tests

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void PPmtArgs1()
		{
			double d = Financial.PPmt (2, -1, 1, 1, 1, DueDate.EndOfPeriod);
		}
		
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void PPmtArgs2()
		{
			double d = Financial.PPmt (1, 2, 1, 1, 1, DueDate.BegOfPeriod);
		}

		[Test]
		public void PPmt()
		{
			double d = Financial.PPmt (10, 2, 3, 7, 9, DueDate.BegOfPeriod);
			Assert.AreEqual(-0.120300751879702, d, 1E-10, "#PPmt01");
			
			d = Financial.PPmt (10, 4, 4, 7, 4, DueDate.EndOfPeriod);
			Assert.AreEqual(-10.0006830600969, d, 1E-10, "#PPmt02");
			
			d = Financial.PPmt (0, 5, 7, 7, 2, DueDate.BegOfPeriod);
			Assert.AreEqual(-1.28571428571429, d, 1E-10, "#PPmt03");
			
			d = Financial.PPmt (-5, 5, 7, -7, -2, DueDate.BegOfPeriod);
			Assert.AreEqual( -0.175770521818777, d, 1E-10, "#PPmt04");
		}

		[Test]
		public void PPmt_1()
		{
			Assert.AreEqual(-1066.4547405246804, Financial.PPmt(0.1/48, 36, 48, 50000, 0, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(-1040.1509285128539, Financial.PPmt(0.1/48, 24, 48, 50000, 0, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(-1093.4237353550643, Financial.PPmt(0.1/48, 48, 48, 50000, 0, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(-1064.2375789019673, Financial.PPmt(0.1/48, 36, 48, 50000, 0, DueDate.BegOfPeriod), 1E-8);

			Assert.AreEqual(-1037.988452569999, Financial.PPmt(0.1/48, 24, 48, 50000, 0, DueDate.BegOfPeriod), 1E-8);

			Assert.AreEqual(-1091.1505051360307, Financial.PPmt(0.1/48, 48, 48, 50000, 0, DueDate.BegOfPeriod), 1E-8);

			Assert.AreEqual(-3280.2712060651929, Financial.PPmt(0.1/48, 48, 48, 50000, 100000, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(-3273.4515154080918, Financial.PPmt(0.1/48, 48, 48, 50000, 100000, DueDate.BegOfPeriod), 1E-8);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void PPmt_2()
		{
			// Argument 'Per' is not a valid value.
			Financial.PPmt(0.1/48, 56, 48, 50000, 0, DueDate.EndOfPeriod);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void PPmt_3()
		{
			// Argument 'Per' is not a valid value.
			Financial.PPmt(0.1/48, -48, -48, 50000, 0, DueDate.EndOfPeriod);
		}

		#endregion

		#region NPV Tests

		
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPVArgs1()
		{
			double [] arr = null;
			double d = Financial.NPV (0.0625, ref arr);
		}
		
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPVArgs2()
		{
			double [] arr = new double [] {-70000, 22000, 25000, 28000, 31000};
			double d = Financial.NPV (-1, ref arr);
		}
			
		[Test]
		public void NPV()
		{
			double [] arr = new double [] {-70000, 22000, 25000, 28000, 31000};
			double d = Financial.NPV (0.0625, ref arr);	
			Assert.AreEqual(19312.5702095352, d, 0.000001);
		}

		[Test]
		public void NPV_1()
		{
			double[] values = new double[] {10000, 20000, 30000, 20000, 10000};

			Assert.AreEqual(68028.761075684073, Financial.NPV(0.1, ref values), 1E-7);

			Assert.AreEqual(42877.457964464716, Financial.NPV(0.3, ref values), 1E-7);

			Assert.AreEqual(22007.920515939288, Financial.NPV(0.7, ref values), 1E-7);

			Assert.AreEqual(15312.5, Financial.NPV(1, ref values), 1E-7);

			Assert.AreEqual(5895.8421600621214, Financial.NPV(2.3, ref values), 1E-7);

			Assert.AreEqual(-5203.7070453792549, Financial.NPV(-2.3, ref values), 1E-7);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPV_2()
		{
			//Argument 'Rate' is not a valid value.
			double[] values = new double[] {10000, 20000, 30000, 20000, 10000};

			Financial.NPV(-1, ref values);
		}

		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void NPV_3()
		{
			// Argument 'ValueArray' is Nothing.
			double[] values = null;

			Financial.NPV(0.1, ref values);
		}

		#endregion

		#region PV Tests

		[Test]
		public void TestPV()
		{
			double d = Financial.PV (1, 1, 1, 1, DueDate.BegOfPeriod);
			Assert.AreEqual (-1.5, d, "#PV01");
			
			d = Financial.PV (1, 1, 1, 1, DueDate.EndOfPeriod);
			Assert.AreEqual (-1, d, "#PV02");
		}

		[Test]
		public void PV_1()
		{
			Assert.AreEqual(-4563.2857859855494, Financial.PV(0.1/48, 48, 100, 0, DueDate.EndOfPeriod), 1E-8);
			Assert.AreEqual(4563.2857859855494, Financial.PV(0.1/48, 48, -100, 0, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(3851.0271688809689, Financial.PV(0.45/48, 48, -100, 0, DueDate.EndOfPeriod), 1E-8);
			Assert.AreEqual(19255.135844404842, Financial.PV(0.45/48, 48, -500, 0, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(4572.7926313730195, Financial.PV(0.1/48, 48, -100, 0, DueDate.BegOfPeriod), 1E-8);


			Assert.AreEqual(1848.4911476096459, Financial.PV(0.1/48, 48, -100, 3000, DueDate.EndOfPeriod), 1E-8);
			Assert.AreEqual(7278.0804243614521, Financial.PV(0.1/48, 48, -100, -3000, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(1857.9979929971164, Financial.PV(0.1/48, 48, -100, 3000, DueDate.BegOfPeriod), 1E-8);
			Assert.AreEqual(7287.5872697489231, Financial.PV(0.1/48, 48, -100, -3000, DueDate.BegOfPeriod), 1E-8);

			Assert.AreEqual(-5053.7378976476075, Financial.PV(-0.1/48, 48, 100, 0, DueDate.EndOfPeriod), 1E-8);

			Assert.AreEqual(-5086.9414579281301, Financial.PV(-0.1/48, 48.3, 100, 0, DueDate.EndOfPeriod), 1E-8);
		}

		#endregion
	}
}