1import {
  2  ACCRINT,
  3  CUMPRINC,
  4  CUMIPMT,
  5  DB,
  6  DDB,
  7  DOLLAR,
  8  DOLLARDE,
  9  DOLLARFR,
 10  EFFECT,
 11  PMT,
 12  SYD,
 13  SLN,
 14  NPV,
 15  NPER,
 16  NOMINAL,
 17  MIRR,
 18  IRR,
 19  IPMT,
 20  FV,
 21  PPMT,
 22  FVSCHEDULE,
 23  PV,
 24  RATE
 25} from "../../src/Formulas/Financial";
 26import {
 27  DATE
 28} from "../../src/Formulas/Date";
 29import {
 30  PI
 31} from "../../src/Formulas/Math";
 32import * as ERRORS from "../../src/Errors";
 33import {
 34  assertEquals,
 35  catchAndAssertEquals,
 36  test
 37} from "../Utils/Asserts";
 38import {
 39  Cell
 40} from "../../src/Cell";
 41
 42
 43test("ACCRINT", function(){
 44  assertEquals(ACCRINT(DATE(2000, 1, 1), DATE(2000, 2, 1), DATE(2002, 12, 31), 0.05, Cell.BuildFrom("A1", 100), 4), 14.98631386861314);
 45  assertEquals(ACCRINT(DATE(2000, 1, 1), DATE(2000, 2, 1), DATE(2002, 12, 31), 0.05, 100, 4), 14.98631386861314);
 46  assertEquals(ACCRINT(DATE(2011, 1, 1), DATE(2011, 2, 1), DATE(2014, 7, 1), 0.1, 1000, 1, 0), 350);
 47  assertEquals(ACCRINT(DATE(2001, 1, 1), DATE(2011, 2, 1), DATE(2014, 7, 1), 0.1, 1000, 2, 1), 1349.6186192059456);
 48  assertEquals(ACCRINT(39508, 39691, 39569, 0.1, 1000, 2, 0), 16.666666666666664);
 49  assertEquals(ACCRINT(10000, 1, 20000, 0.1, 1000, 4, 0), 2737.5);
 50  assertEquals(ACCRINT(10000, 1, 20000, 0.1, 1000, 4, 1), 2737.8507871321012); // ms: 2787.087912 (1.76% err), gs: 2737.637363 (0.007% err)
 51  assertEquals(ACCRINT(10000, 1, 20000, 0.1, 1000, 4, 2), 2777.777777777778); // ms, gs: 2737.777778 (1.46% err)
 52  assertEquals(ACCRINT(10000, 1, 20000, 0.1, 1000, 4, 3), 2739.72602739726); //ms, gs: 2737.60274 (0.077% err)
 53  assertEquals(ACCRINT(10000, 1, 20000, 0.1, 1000, 4, 4), 2737.5);
 54  assertEquals(ACCRINT(1, 44, "1461", "0.1", [1000], [1]), 400);
 55  assertEquals(ACCRINT(1, 2, 1461, 0.1, 1000, 1), 400);
 56  assertEquals(ACCRINT(1, 2, 1461, 0.1, 1000, 1, 0), 400);
 57  assertEquals(ACCRINT(1, 2, 1461, 0.1, 1000, 1, 1), 400);
 58  assertEquals(ACCRINT(1, 2, 1461, 0.1, 1000, 1, 2), 405.55555555555554); // gs: 400
 59  assertEquals(ACCRINT(1, 2, 1461, 0.1, 1000, 1, 3), 400); // gs: 399.6575342
 60  assertEquals(ACCRINT(1, 2, 1461, 0.1, 1000, 1, 4), 400);
 61  catchAndAssertEquals(function() {
 62    ACCRINT(1, -1, 100, 0.1, 1000, 1, 4);
 63  }, ERRORS.NUM_ERROR);
 64  catchAndAssertEquals(function() {
 65    ACCRINT(100, 2, 1, 0.1, 1000, 1, 4);
 66  }, ERRORS.NUM_ERROR);
 67  catchAndAssertEquals(function() {
 68    ACCRINT.apply(this, [100, 2, 1, 0.1, 1000]);
 69  }, ERRORS.NA_ERROR);
 70  catchAndAssertEquals(function() {
 71    ACCRINT.apply(this, [1, 2, 1461, 0.1, 1000, 1, 1, 1]);
 72  }, ERRORS.NA_ERROR);
 73});
 74
 75
 76test("CUMPRINC", function(){
 77  assertEquals(CUMPRINC(0.12, 12, 100, 1, Cell.BuildFrom("A1", 5), false), -26.324171373034403);
 78  assertEquals(CUMPRINC(0.12, 12, 100, 1, 5, false), -26.324171373034403);
 79  assertEquals(CUMPRINC(0.12, 12, 100, 1, 5, 0), -26.324171373034403);
 80  assertEquals(CUMPRINC(0.12, 12, 100, 1, 5, true), -34.21801015449499);
 81  assertEquals(CUMPRINC(0.12, 12, 100, 1, 5, -11), -34.21801015449499);
 82  catchAndAssertEquals(function() {
 83    CUMPRINC(0.12, 12, 100, 1, 5, []);
 84  }, ERRORS.REF_ERROR);
 85  catchAndAssertEquals(function() {
 86    CUMPRINC(0.12, 12, 100, 0, 5, false);
 87  }, ERRORS.NUM_ERROR);
 88  catchAndAssertEquals(function() {
 89    CUMPRINC(0.12, 12, 100, 3, 1, false);
 90  }, ERRORS.NUM_ERROR);
 91  catchAndAssertEquals(function() {
 92    CUMPRINC.apply(this, []);
 93  }, ERRORS.NA_ERROR);
 94  catchAndAssertEquals(function() {
 95    CUMPRINC.apply(this, [0.12, 12, 100, 1, 5, true, 55]);
 96  }, ERRORS.NA_ERROR);
 97  catchAndAssertEquals(function() {
 98    CUMPRINC.apply(this, [0.12, 12, 100, 1, 5]);
 99  }, ERRORS.NA_ERROR);
100});
101
102
103test("CUMIPMT", function(){
104  assertEquals(CUMIPMT(0.12, 12, 100, 1, Cell.BuildFrom("A1", 5), 0), -54.39423242396348);
105  assertEquals(CUMIPMT(0.12, 12, 100, 1, 5, 0), -54.39423242396348);
106  assertEquals(CUMIPMT(0.12, 12, 100, 1, 5, false), -54.39423242396348);
107  assertEquals(CUMIPMT(0.12, 12, 100, 1, 5, true), -37.851993235681675);
108  assertEquals(CUMIPMT(0.12, 12, 100, 1, 5, 1), -37.851993235681675);
109  assertEquals(CUMIPMT(0.12, 12, 100, 2, 6, 1), -45.74583201714228);
110  assertEquals(CUMIPMT(0.12, 12, 100, 2, 6, true), -45.74583201714228);
111  assertEquals(CUMIPMT([0.12], ["12"], [100, "str"], "1", 5, 0), -54.39423242396348);
112  catchAndAssertEquals(function() {
113    CUMIPMT(0.12, 12, 100, 1, 5, []);
114  }, ERRORS.REF_ERROR);
115  catchAndAssertEquals(function() {
116    CUMIPMT(0.12, 12, 100, 0, 5, false);
117  }, ERRORS.NUM_ERROR);
118  catchAndAssertEquals(function() {
119    CUMIPMT(0.12, 12, 100, 3, 1, false);
120  }, ERRORS.NUM_ERROR);
121  catchAndAssertEquals(function() {
122    CUMIPMT.apply(this, []);
123  }, ERRORS.NA_ERROR);
124  catchAndAssertEquals(function() {
125    CUMIPMT.apply(this, [0.12, 12, 100, 1, 5, true, 55]);
126  }, ERRORS.NA_ERROR);
127  catchAndAssertEquals(function() {
128    CUMIPMT.apply(this, [0.12, 12, 100, 1, 5]);
129  }, ERRORS.NA_ERROR);
130});
131
132
133test("DB", function(){
134  assertEquals(DB(100, 50, 10, 2, Cell.BuildFrom("A1", 12)), 6.2482428240683285);
135  assertEquals(DB(100, 50, 10, 2, 12), 6.2482428240683285);
136  assertEquals(DB("100", "50", "10", "2", "12"), 6.2482428240683285);
137  assertEquals(DB(100, 50, 10, 2, 12.9999999), 6.2482428240683285);
138  catchAndAssertEquals(function() {
139    DB(100, 50, 10, 2, 13);
140  }, ERRORS.NUM_ERROR);
141  catchAndAssertEquals(function() {
142    DB(100, 50, 10, 12, 2);
143  }, ERRORS.NUM_ERROR);
144  catchAndAssertEquals(function() {
145    DB(100, -50, 10, 2, 12);
146  }, ERRORS.NUM_ERROR);
147});
148
149
150test("DDB", function(){
151  assertEquals(DDB(100, 50, 10, 2, Cell.BuildFrom("A1", 2.25)), 17.4375);
152  assertEquals(DDB(100, 50, 10, 2, 2.25), 17.4375);
153  assertEquals(DDB(100, [50], 10, 2, "2.25"), 17.4375);
154  catchAndAssertEquals(function() {
155    DDB.apply(this, [100, 50, 10, 12, 2.25]);
156  }, ERRORS.NUM_ERROR);
157  catchAndAssertEquals(function() {
158    DDB.apply(this, [100, -50, 10, 2, 12]);
159  }, ERRORS.NUM_ERROR);
160});
161
162
163test("DOLLAR", function(){
164  assertEquals(DOLLAR(1.2351, Cell.BuildFrom("A1", 4)), 1.2351);
165  assertEquals(DOLLAR(1.2351, 4), 1.2351);
166  assertEquals(DOLLAR(1.2351, 2), 1.23);
167  assertEquals(DOLLAR("$3.141592653589793", "2"), 3.14);
168  assertEquals(DOLLAR("-$3.141592653589793", "2"), -3.14);
169  assertEquals(DOLLAR("$-3.141592653589793", "2"), -3.14);
170  assertEquals(DOLLAR(PI(), 1), 3.1);
171  assertEquals(DOLLAR(PI(), 0), 3);
172  assertEquals(DOLLAR(PI(), false), 3);
173  assertEquals(DOLLAR(PI(), -1), 0);
174  assertEquals(DOLLAR(31.41592653589793, -1), 30);
175  assertEquals(DOLLAR([31.41592653589793], [-1]), 30);
176  assertEquals(DOLLAR(31111.41592653589793, -4), 30000);
177  assertEquals(DOLLAR(31111.41592653589793, -2), 31100);
178  catchAndAssertEquals(function() {
179    DOLLAR.apply(this, []);
180  }, ERRORS.NA_ERROR);
181  catchAndAssertEquals(function() {
182    DOLLAR.apply(this, [3.1, 1, 1]);
183  }, ERRORS.NA_ERROR);
184});
185
186
187test("DOLLARDE", function(){
188  assertEquals(DOLLARDE(0, Cell.BuildFrom("A1", 32)), 0);
189  assertEquals(DOLLARDE(0, 32), 0);
190  assertEquals(DOLLARDE(100.1, 32), 100.3125);
191  assertEquals(DOLLARDE(100.1, 32.9999), 100.3125);
192  assertEquals(DOLLARDE("100.1", [32, "str"]), 100.3125);
193  catchAndAssertEquals(function() {
194    DOLLARDE(100, []);
195  }, ERRORS.REF_ERROR);
196  catchAndAssertEquals(function() {
197    DOLLARDE(100, "str");
198  }, ERRORS.VALUE_ERROR);
199  catchAndAssertEquals(function() {
200    DOLLARDE(100, 0);
201  }, ERRORS.DIV_ZERO_ERROR);
202  catchAndAssertEquals(function() {
203    DOLLARDE(100, 0.99);
204  }, ERRORS.DIV_ZERO_ERROR);
205  catchAndAssertEquals(function() {
206    DOLLARDE.apply(this, []);
207  }, ERRORS.NA_ERROR);
208  catchAndAssertEquals(function() {
209    DOLLARDE.apply(this, [3.1]);
210  }, ERRORS.NA_ERROR);
211  catchAndAssertEquals(function() {
212    DOLLARDE.apply(this, [3.1, 32, 22]);
213  }, ERRORS.NA_ERROR);
214});
215
216
217test("DOLLARFR", function(){
218  assertEquals(DOLLARFR(100.1, Cell.BuildFrom("A1", 32)), 100.032);
219  assertEquals(DOLLARFR(100.1, 32), 100.032);
220  assertEquals(DOLLARFR(100.1, 32), 100.032);
221  assertEquals(DOLLARFR(100.1, 32.9999), 100.032);
222  assertEquals(DOLLARFR("100.1", [32, "str"]), 100.032);
223  catchAndAssertEquals(function() {
224    DOLLARFR(100, []);
225  }, ERRORS.REF_ERROR);
226  catchAndAssertEquals(function() {
227    DOLLARFR(100, "str");
228  }, ERRORS.VALUE_ERROR);
229  catchAndAssertEquals(function() {
230    DOLLARFR(100, 0);
231  }, ERRORS.DIV_ZERO_ERROR);
232  catchAndAssertEquals(function() {
233    DOLLARFR(100, 0.99);
234  }, ERRORS.DIV_ZERO_ERROR);
235  catchAndAssertEquals(function() {
236    DOLLARFR.apply(this, []);
237  }, ERRORS.NA_ERROR);
238  catchAndAssertEquals(function() {
239    DOLLARFR.apply(this, [3.1]);
240  }, ERRORS.NA_ERROR);
241  catchAndAssertEquals(function() {
242    DOLLARFR.apply(this, [3.1, 32, 22]);
243  }, ERRORS.NA_ERROR);
244});
245
246
247test("EFFECT", function(){
248  assertEquals(EFFECT(0.99, Cell.BuildFrom("A1", 12)), 1.5890167507927795);
249  assertEquals(EFFECT(0.99, 12), 1.5890167507927795);
250  assertEquals(EFFECT(0.99, 12.111), 1.5890167507927795);
251  assertEquals(EFFECT(0.99, 12.999), 1.5890167507927795);
252  assertEquals(EFFECT("100000", 12.999), 1.123182670038387e+47);
253  assertEquals(EFFECT([100000], [12.999]), 1.123182670038387e+47);
254  catchAndAssertEquals(function() {
255    EFFECT.apply(this, []);
256  }, ERRORS.NA_ERROR);
257  catchAndAssertEquals(function() {
258    EFFECT.apply(this, [0.99]);
259  }, ERRORS.NA_ERROR);
260  catchAndAssertEquals(function() {
261    EFFECT(-0.99, 12);
262  }, ERRORS.NUM_ERROR);
263  catchAndAssertEquals(function() {
264    EFFECT(0.99, 0);
265  }, ERRORS.NUM_ERROR);
266  catchAndAssertEquals(function() {
267    EFFECT(0.99, "str");
268  }, ERRORS.VALUE_ERROR);
269  catchAndAssertEquals(function() {
270    EFFECT(0.99, []);
271  }, ERRORS.REF_ERROR);
272});
273
274
275test("PMT", function() {
276  assertEquals(PMT(0.05/12, 30*12, 100000), -536.8216230121382);
277  assertEquals(PMT(0.05/12, 30*12, 100000, 10000), -548.8371186466853);
278  assertEquals(PMT(0.05/12, 30*12, 100000, 10000, 0), -548.8371186466853);
279  assertEquals(PMT(0.05/12, 30*12, 100000, 10000, false), -548.8371186466853);
280  assertEquals(PMT(0.05/12, 30*12, 100000, 10000, 1), -546.559786204168);
281  assertEquals(PMT(0.05/12, 30*12, 100000, 10000, 100), -546.559786204168);
282  assertEquals(PMT([0.05/12, []], [30*12], ["100000"]), -536.8216230121382);
283  assertEquals(PMT(-0.0001, 30*12, 100000, 10000, 1), -301.1033887993179);
284  assertEquals(PMT(-0.0001, 1, 100000, 10000, 1), -110001.000100094);
285  assertEquals(PMT(-0.0001, 1, 0, 10000, 1), -10001.0001000111);
286  assertEquals(PMT(-0.0001, 1, 0, 0, 1), 0);
287  catchAndAssertEquals(function() {
288    PMT.apply(this, [[[0.05/12]], [], ["100000"]]);
289  }, ERRORS.REF_ERROR);
290  catchAndAssertEquals(function() {
291    PMT.apply(this);
292  }, ERRORS.NA_ERROR);
293  catchAndAssertEquals(function() {
294    PMT.apply(this, [0.05/12, 30*12, 100000, 10000, 1, "nope"]);
295  }, ERRORS.NA_ERROR);
296});
297
298
299test("SYD", function() {
300  assertEquals(SYD(100, 22, 10, 3), 11.345454545454546);
301  assertEquals(SYD(33.99, 22, 10, 3), 1.7440000000000002);
302  assertEquals(SYD(39, 22, 1000, 300), 0.02381018981018981);
303  catchAndAssertEquals(function() {
304    SYD(39, 22, 10, 300);
305  }, ERRORS.NUM_ERROR);
306  catchAndAssertEquals(function() {
307    SYD(39, 22, 10, -3);
308  }, ERRORS.NUM_ERROR);
309  catchAndAssertEquals(function() {
310    SYD.apply(this, [10, 10, 10]);
311  }, ERRORS.NA_ERROR);
312  catchAndAssertEquals(function() {
313    SYD.apply(this, [10, 10, 10, 10, 10]);
314  }, ERRORS.NA_ERROR);
315});
316
317
318test("SLN", function() {
319  assertEquals(SLN(100, 22, 10), 7.80);
320  assertEquals(SLN(22.99, 1, 1), 21.99);
321  assertEquals(SLN(22.99, 1, -1), -21.99);
322  catchAndAssertEquals(function() {
323    SLN(39, 22, 0);
324  }, ERRORS.DIV_ZERO_ERROR);
325  catchAndAssertEquals(function() {
326    SLN.apply(this, [10, 10]);
327  }, ERRORS.NA_ERROR);
328  catchAndAssertEquals(function() {
329    SLN.apply(this, [10, 10, 10, 10]);
330  }, ERRORS.NA_ERROR);
331});
332
333
334test("NPV", function() {
335  assertEquals(NPV(0.01, 200, 100, 22, 99.1), 416.7618977366809);
336  assertEquals(NPV(0.01, 200, -100, 1.4, -100.2, 22, 99.1, "100"), 214.7457214025921);
337  assertEquals(NPV(0.01, 200, -100, 1.4, -100.2, 22, 99.1), 120.54119787717146);
338  assertEquals(NPV(0.01, 200, 100, 22, 99000), 96409.00105891385);
339  catchAndAssertEquals(function() {
340    NPV.apply(this, [10]);
341  }, ERRORS.NA_ERROR);
342  catchAndAssertEquals(function() {
343    NPV.apply(this, [10, 10, 20, "str"]);
344  }, ERRORS.VALUE_ERROR);
345});
346
347
348test("NPER", function() {
349  assertEquals(NPER(0.04, 100, 4000, 0, 0), -24.362418941571313);
350  assertEquals(NPER(0.04, 100, 4000), -24.362418941571313);
351  assertEquals(NPER(0.02, 100, 4000, 0, 0), -29.68225660720854);
352  assertEquals(NPER(0.01, 100, 4000, 0, 0), -33.815180780052486);
353  assertEquals(NPER(0.04, -50, 1000, 20, 0), 41.44012515117696);
354  assertEquals(NPER(-0.04, -50, 1000, 20, 0), 14.79388878297825);
355  assertEquals(NPER(0.04, -50, 1000, 2000, 1), 61.13849239372526);
356  assertEquals(NPER(0.04, -50, 1000, 2000, 0), 65.39782556827234);
357  catchAndAssertEquals(function() {
358    NPER(0.04, 50, 1000, 2000, 0);
359  }, ERRORS.NUM_ERROR);
360  catchAndAssertEquals(function() {
361    NPER.apply(this, [0.04, 100]);
362  }, ERRORS.NA_ERROR);
363  catchAndAssertEquals(function() {
364    NPER.apply(this, [0.04, -50, 1000, 2000, 0, 22]);
365  }, ERRORS.NA_ERROR);
366});
367
368
369test("NOMINAL", function() {
370  assertEquals(NOMINAL(0.8, 12), 0.6024201620105654);
371  assertEquals(NOMINAL(0.9, 2), 0.7568097504180442);
372  catchAndAssertEquals(function() {
373    NOMINAL(0.04, -2);
374  }, ERRORS.NUM_ERROR);
375  catchAndAssertEquals(function() {
376    NOMINAL.apply(this, [0.04, -50, 44]);
377  }, ERRORS.NA_ERROR);
378  catchAndAssertEquals(function() {
379    NOMINAL.apply(this, [0.04]);
380  }, ERRORS.NA_ERROR);
381});
382
383
384test("MIRR", function() {
385  assertEquals(MIRR([10, 20, -30, 40], 0.05, 0.06), 0.3458084697540138);
386  assertEquals(MIRR([10, 20, -30, 40, 10, 22, -100], 0.01, 0.02), -0.02762369541445353);
387  catchAndAssertEquals(function() {
388    MIRR([10, 20, 30, 40], 0.05, 0.06);
389  }, ERRORS.DIV_ZERO_ERROR);
390  catchAndAssertEquals(function() {
391    MIRR.apply(this, [[10, 20, 30, -10], 0.05]);
392  }, ERRORS.NA_ERROR);
393  catchAndAssertEquals(function() {
394    MIRR.apply(this, [[10, 20, 30, -10], 0.05, 0.01, 0.09]);
395  }, ERRORS.NA_ERROR);
396});
397
398
399test("MIRR", function() {
400  assertEquals(IRR([-1, 4, 10, 15, -22, 99, 44, 1000, -10, "ignore"]), 5.059102535247803);
401  assertEquals(IRR([-1, 4, 10, 15, -22, 99, 44, 1000, -10]), 5.059102535247803);
402  assertEquals(IRR([-1, 4, 10, 15, -22, 99, 44, 1000, -10], 0.1), 5.059102535247803);
403  assertEquals(IRR([-100, 100, 100, 100, 100, 100]), 0.9659482464194298);
404  assertEquals(IRR([-100, 100, 100, 100, 100]), 0.9275619648396969);
405  assertEquals(IRR([-4000, 200, 250, 300, 350]), -0.35242662353266496);
406  assertEquals(IRR([-100, 100]), 9.313225746154785e-9);
407  assertEquals(IRR([-100, 100, 100]), 0.6180339809507132);
408  catchAndAssertEquals(function() {
409    IRR.apply(this, []);
410  }, ERRORS.NA_ERROR);
411  catchAndAssertEquals(function() {
412    IRR.apply(this, [[100, 100, 100], 0.01, 4.4]);
413  }, ERRORS.NA_ERROR);
414});
415
416
417test("IPMT", function() {
418  assertEquals(IPMT(0.025, 1, 66, 25000), -625);
419  assertEquals(IPMT(0.025, 1, 66, 25000, 0, 0), -625);
420  assertEquals(IPMT(0.025, 1, 66, 25000, 1, 1), 0);
421  assertEquals(IPMT(0.025, 1, 66, 25000, 1, 0), -625);
422  assertEquals(IPMT(100, 1, 66, 25000, 0), -2500000);
423  assertEquals(IPMT(0.1, 4, 660, 4, 1), -0.4);
424  catchAndAssertEquals(function() {
425    IPMT.apply(this, [0.025, 1, 66]);
426  }, ERRORS.NA_ERROR);
427  catchAndAssertEquals(function() {
428    IPMT.apply(this, [0.025, 1, 66, 25000, 0, 0, 1]);
429  }, ERRORS.NA_ERROR);
430});
431
432
433test("FV", function() {
434  assertEquals(FV(0.025, 1, 66, 25000, 0), -25690.999999999996);
435  assertEquals(FV(0.025, 1, 66, 25000), -25690.999999999996);
436  assertEquals(FV(0.05, 1, 66, 25000), -26316);
437  assertEquals(FV(0.025, 1, 66, 25000, 1), -25692.649999999998);
438  catchAndAssertEquals(function() {
439    FV.apply(this, [0.025, 1, 66, 25000, 1, 4]);
440  }, ERRORS.NA_ERROR);
441  catchAndAssertEquals(function() {
442    FV.apply(this, [0.025, 1]);
443  }, ERRORS.NA_ERROR);
444});
445
446
447test("PPMT", function() {
448  assertEquals(PPMT(0.025, 4, 24, 50000, 0, 1), -1623.8890945416422);
449  assertEquals(PPMT(0.010, 3, 24, 33000, 0, 1), -1235.6588292014105);
450  assertEquals(PPMT(0, 3, 24, 33000, 0, 1), -1375.00);
451  assertEquals(PPMT(0, 3, 24, 0, 0, 1), 0);
452  assertEquals(PPMT(0, 1, 3, 100, -1000, 1), 300);
453  catchAndAssertEquals(function() {
454    PPMT(0, 0, 24, 33000, 0, 1)
455  }, ERRORS.NUM_ERROR);
456  catchAndAssertEquals(function() {
457    PPMT(0, 4, 0, 33000, 0, 1)
458  }, ERRORS.NUM_ERROR);
459  catchAndAssertEquals(function() {
460    PPMT.apply(this, [0, 4, 0]);
461  }, ERRORS.NA_ERROR);
462  catchAndAssertEquals(function() {
463    PPMT.apply(this, [0, 4, 0, 4000, 1, 1, 1]);
464  }, ERRORS.NA_ERROR);
465});
466
467
468test("FVSCHEDULE", function() {
469  assertEquals(FVSCHEDULE(0.025, [1, 2, 3, 4]), 3.0000000000000004);
470  assertEquals(FVSCHEDULE(0.025, [1, 2, 3, 4]), 3.0000000000000004);
471  assertEquals(FVSCHEDULE(20000, [0.01, 0.04, 0.1, 0.01]), 23339.888000000003);
472  assertEquals(FVSCHEDULE(0, [1, 2]), 0);
473  assertEquals(FVSCHEDULE(-1, [1, 2]), -6);
474  catchAndAssertEquals(function() {
475    FVSCHEDULE.apply(this, [0.025, []]);
476  }, ERRORS.REF_ERROR);
477  catchAndAssertEquals(function() {
478    FVSCHEDULE.apply(this, [0.025, [1, 2, 3, 4], 3]);
479  }, ERRORS.NA_ERROR);
480  catchAndAssertEquals(function() {
481    FVSCHEDULE.apply(this, [0.025]);
482  }, ERRORS.NA_ERROR);
483});
484
485
486test("PV", function() {
487  assertEquals(PV(2, 12, 100), -49.99990591617884);
488  assertEquals(PV(2, 12, 200), -99.99981183235768);
489  assertEquals(PV(2, -1, 200), 200.00000000000003);
490  assertEquals(PV(2, 1, 0), 0);
491  assertEquals(PV(2, 1, 0, 100), -33.333333333333336);
492  assertEquals(PV(2, 1, 0, 100), -33.333333333333336);
493  assertEquals(PV(2, 3, 100, 100, 1), -148.14814814814815);
494  assertEquals(PV(2, 3, 100, 100, 0), -51.851851851851855);
495  catchAndAssertEquals(function() {
496    PV(-1, 12, 100);
497  }, ERRORS.NUM_ERROR);
498  catchAndAssertEquals(function() {
499    PV.apply(this, [0, 1]);
500  }, ERRORS.NA_ERROR);
501  catchAndAssertEquals(function() {
502    PV.apply(this, [0, 1, 2, 3, 4, 5]);
503  }, ERRORS.NA_ERROR);
504});
505
506
507test("RATE", function() {
508  assertEquals(RATE(12, -100, 400, 0, 0, 0.1), 0.22893307069316507);
509  assertEquals(RATE(360, -665.3, 99000), 0.005916521358085446);
510  assertEquals(RATE(360, -958.63, 192000), 0.0036458502960158515);
511  assertEquals(RATE(180, -1302.96, 192000), 0.0022917255526408564);
512  assertEquals(RATE(360, -889.19, 192000), 0.0031250616819306744);
513  assertEquals(RATE(360, -1145.8, 240000), 0.003333353153720964);
514  assertEquals(RATE(360, -665.3, 99000, 10), 0.00591642102735932);
515  assertEquals(RATE(12, -100, 400, 100), 0.2225948800332845);
516  assertEquals(RATE(360, -665.3, 99000, 10, 1), 0.005965913048930816);
517  catchAndAssertEquals(function() {
518    RATE(0, -100, 400, 10);
519  }, ERRORS.NUM_ERROR);
520  catchAndAssertEquals(function() {
521    RATE(12, -100, 400, 1000000);
522  }, ERRORS.NUM_ERROR);
523  catchAndAssertEquals(function() {
524    RATE.apply(this, [0, 1]);
525  }, ERRORS.NA_ERROR);
526  catchAndAssertEquals(function() {
527    RATE.apply(this, [1, 2, 3, 4, 5, 6, 7]);
528  }, ERRORS.NA_ERROR);
529});