ILIAS  release_5-2 Revision v5.2.25-18-g3f80b828510
Financial.php
Go to the documentation of this file.
1<?php
30if (!defined('PHPEXCEL_ROOT')) {
34 define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
35 require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
36}
37
38
40define('FINANCIAL_MAX_ITERATIONS', 128);
41
43define('FINANCIAL_PRECISION', 1.0e-08);
44
45
53class PHPExcel_Calculation_Financial {
54
63 private static function _lastDayOfMonth($testDate)
64 {
65 return ($testDate->format('d') == $testDate->format('t'));
66 } // function _lastDayOfMonth()
67
68
77 private static function _firstDayOfMonth($testDate)
78 {
79 return ($testDate->format('d') == 1);
80 } // function _firstDayOfMonth()
81
82
83 private static function _coupFirstPeriodDate($settlement, $maturity, $frequency, $next)
84 {
85 $months = 12 / $frequency;
86
87 $result = PHPExcel_Shared_Date::ExcelToPHPObject($maturity);
88 $eom = self::_lastDayOfMonth($result);
89
90 while ($settlement < PHPExcel_Shared_Date::PHPToExcel($result)) {
91 $result->modify('-'.$months.' months');
92 }
93 if ($next) {
94 $result->modify('+'.$months.' months');
95 }
96
97 if ($eom) {
98 $result->modify('-1 day');
99 }
100
101 return PHPExcel_Shared_Date::PHPToExcel($result);
102 } // function _coupFirstPeriodDate()
103
104
105 private static function _validFrequency($frequency)
106 {
107 if (($frequency == 1) || ($frequency == 2) || ($frequency == 4)) {
108 return true;
109 }
110 if ((PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) &&
111 (($frequency == 6) || ($frequency == 12))) {
112 return true;
113 }
114 return false;
115 } // function _validFrequency()
116
117
132 private static function _daysPerYear($year, $basis=0)
133 {
134 switch ($basis) {
135 case 0 :
136 case 2 :
137 case 4 :
138 $daysPerYear = 360;
139 break;
140 case 3 :
141 $daysPerYear = 365;
142 break;
143 case 1 :
144 $daysPerYear = (PHPExcel_Calculation_DateTime::_isLeapYear($year)) ? 366 : 365;
145 break;
146 default :
147 return PHPExcel_Calculation_Functions::NaN();
148 }
149 return $daysPerYear;
150 } // function _daysPerYear()
151
152
153 private static function _interestAndPrincipal($rate=0, $per=0, $nper=0, $pv=0, $fv=0, $type=0)
154 {
155 $pmt = self::PMT($rate, $nper, $pv, $fv, $type);
156 $capital = $pv;
157 for ($i = 1; $i<= $per; ++$i) {
158 $interest = ($type && $i == 1) ? 0 : -$capital * $rate;
159 $principal = $pmt - $interest;
160 $capital += $principal;
161 }
162 return array($interest, $principal);
163 } // function _interestAndPrincipal()
164
165
201 public static function ACCRINT($issue, $firstinterest, $settlement, $rate, $par=1000, $frequency=1, $basis=0)
202 {
203 $issue = PHPExcel_Calculation_Functions::flattenSingleValue($issue);
204 $firstinterest = PHPExcel_Calculation_Functions::flattenSingleValue($firstinterest);
205 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
206 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
207 $par = (is_null($par)) ? 1000 : PHPExcel_Calculation_Functions::flattenSingleValue($par);
208 $frequency = (is_null($frequency)) ? 1 : PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
209 $basis = (is_null($basis)) ? 0 : PHPExcel_Calculation_Functions::flattenSingleValue($basis);
210
211 // Validate
212 if ((is_numeric($rate)) && (is_numeric($par))) {
213 $rate = (float) $rate;
214 $par = (float) $par;
215 if (($rate <= 0) || ($par <= 0)) {
216 return PHPExcel_Calculation_Functions::NaN();
217 }
218 $daysBetweenIssueAndSettlement = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $settlement, $basis);
219 if (!is_numeric($daysBetweenIssueAndSettlement)) {
220 // return date error
221 return $daysBetweenIssueAndSettlement;
222 }
223
224 return $par * $rate * $daysBetweenIssueAndSettlement;
225 }
226 return PHPExcel_Calculation_Functions::VALUE();
227 } // function ACCRINT()
228
229
253 public static function ACCRINTM($issue, $settlement, $rate, $par=1000, $basis=0) {
254 $issue = PHPExcel_Calculation_Functions::flattenSingleValue($issue);
255 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
256 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
257 $par = (is_null($par)) ? 1000 : PHPExcel_Calculation_Functions::flattenSingleValue($par);
258 $basis = (is_null($basis)) ? 0 : PHPExcel_Calculation_Functions::flattenSingleValue($basis);
259
260 // Validate
261 if ((is_numeric($rate)) && (is_numeric($par))) {
262 $rate = (float) $rate;
263 $par = (float) $par;
264 if (($rate <= 0) || ($par <= 0)) {
265 return PHPExcel_Calculation_Functions::NaN();
266 }
267 $daysBetweenIssueAndSettlement = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $settlement, $basis);
268 if (!is_numeric($daysBetweenIssueAndSettlement)) {
269 // return date error
270 return $daysBetweenIssueAndSettlement;
271 }
272 return $par * $rate * $daysBetweenIssueAndSettlement;
273 }
274 return PHPExcel_Calculation_Functions::VALUE();
275 } // function ACCRINTM()
276
277
309 public static function AMORDEGRC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis=0) {
310 $cost = PHPExcel_Calculation_Functions::flattenSingleValue($cost);
311 $purchased = PHPExcel_Calculation_Functions::flattenSingleValue($purchased);
312 $firstPeriod = PHPExcel_Calculation_Functions::flattenSingleValue($firstPeriod);
313 $salvage = PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
314 $period = floor(PHPExcel_Calculation_Functions::flattenSingleValue($period));
315 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
316 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
317
318 // The depreciation coefficients are:
319 // Life of assets (1/rate) Depreciation coefficient
320 // Less than 3 years 1
321 // Between 3 and 4 years 1.5
322 // Between 5 and 6 years 2
323 // More than 6 years 2.5
324 $fUsePer = 1.0 / $rate;
325 if ($fUsePer < 3.0) {
326 $amortiseCoeff = 1.0;
327 } elseif ($fUsePer < 5.0) {
328 $amortiseCoeff = 1.5;
329 } elseif ($fUsePer <= 6.0) {
330 $amortiseCoeff = 2.0;
331 } else {
332 $amortiseCoeff = 2.5;
333 }
334
335 $rate *= $amortiseCoeff;
336 $fNRate = round(PHPExcel_Calculation_DateTime::YEARFRAC($purchased, $firstPeriod, $basis) * $rate * $cost,0);
337 $cost -= $fNRate;
338 $fRest = $cost - $salvage;
339
340 for ($n = 0; $n < $period; ++$n) {
341 $fNRate = round($rate * $cost,0);
342 $fRest -= $fNRate;
343
344 if ($fRest < 0.0) {
345 switch ($period - $n) {
346 case 0 :
347 case 1 : return round($cost * 0.5, 0);
348 break;
349 default : return 0.0;
350 break;
351 }
352 }
353 $cost -= $fNRate;
354 }
355 return $fNRate;
356 } // function AMORDEGRC()
357
358
385 public static function AMORLINC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis=0) {
386 $cost = PHPExcel_Calculation_Functions::flattenSingleValue($cost);
387 $purchased = PHPExcel_Calculation_Functions::flattenSingleValue($purchased);
388 $firstPeriod = PHPExcel_Calculation_Functions::flattenSingleValue($firstPeriod);
389 $salvage = PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
390 $period = PHPExcel_Calculation_Functions::flattenSingleValue($period);
391 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
392 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
393
394 $fOneRate = $cost * $rate;
395 $fCostDelta = $cost - $salvage;
396 // Note, quirky variation for leap years on the YEARFRAC for this function
397 $purchasedYear = PHPExcel_Calculation_DateTime::YEAR($purchased);
398 $yearFrac = PHPExcel_Calculation_DateTime::YEARFRAC($purchased, $firstPeriod, $basis);
399
400 if (($basis == 1) && ($yearFrac < 1) && (PHPExcel_Calculation_DateTime::_isLeapYear($purchasedYear))) {
401 $yearFrac *= 365 / 366;
402 }
403
404 $f0Rate = $yearFrac * $rate * $cost;
405 $nNumOfFullPeriods = intval(($cost - $salvage - $f0Rate) / $fOneRate);
406
407 if ($period == 0) {
408 return $f0Rate;
409 } elseif ($period <= $nNumOfFullPeriods) {
410 return $fOneRate;
411 } elseif ($period == ($nNumOfFullPeriods + 1)) {
412 return ($fCostDelta - $fOneRate * $nNumOfFullPeriods - $f0Rate);
413 } else {
414 return 0.0;
415 }
416 } // function AMORLINC()
417
418
451 public static function COUPDAYBS($settlement, $maturity, $frequency, $basis=0) {
452 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
453 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
454 $frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
455 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
456
457 if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
458 return PHPExcel_Calculation_Functions::VALUE();
459 }
460 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
461 return PHPExcel_Calculation_Functions::VALUE();
462 }
463
464 if (($settlement > $maturity) ||
465 (!self::_validFrequency($frequency)) ||
466 (($basis < 0) || ($basis > 4))) {
467 return PHPExcel_Calculation_Functions::NaN();
468 }
469
470 $daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
471 $prev = self::_coupFirstPeriodDate($settlement, $maturity, $frequency, False);
472
473 return PHPExcel_Calculation_DateTime::YEARFRAC($prev, $settlement, $basis) * $daysPerYear;
474 } // function COUPDAYBS()
475
476
509 public static function COUPDAYS($settlement, $maturity, $frequency, $basis=0) {
510 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
511 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
512 $frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
513 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
514
515 if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
516 return PHPExcel_Calculation_Functions::VALUE();
517 }
518 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
519 return PHPExcel_Calculation_Functions::VALUE();
520 }
521
522 if (($settlement > $maturity) ||
523 (!self::_validFrequency($frequency)) ||
524 (($basis < 0) || ($basis > 4))) {
525 return PHPExcel_Calculation_Functions::NaN();
526 }
527
528 switch ($basis) {
529 case 3: // Actual/365
530 return 365 / $frequency;
531 case 1: // Actual/actual
532 if ($frequency == 1) {
533 $daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($maturity),$basis);
534 return ($daysPerYear / $frequency);
535 } else {
536 $prev = self::_coupFirstPeriodDate($settlement, $maturity, $frequency, False);
537 $next = self::_coupFirstPeriodDate($settlement, $maturity, $frequency, True);
538 return ($next - $prev);
539 }
540 default: // US (NASD) 30/360, Actual/360 or European 30/360
541 return 360 / $frequency;
542 }
543 return PHPExcel_Calculation_Functions::VALUE();
544 } // function COUPDAYS()
545
546
579 public static function COUPDAYSNC($settlement, $maturity, $frequency, $basis=0) {
580 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
581 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
582 $frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
583 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
584
585 if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
586 return PHPExcel_Calculation_Functions::VALUE();
587 }
588 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
589 return PHPExcel_Calculation_Functions::VALUE();
590 }
591
592 if (($settlement > $maturity) ||
593 (!self::_validFrequency($frequency)) ||
594 (($basis < 0) || ($basis > 4))) {
595 return PHPExcel_Calculation_Functions::NaN();
596 }
597
598 $daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
599 $next = self::_coupFirstPeriodDate($settlement, $maturity, $frequency, True);
600
601 return PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $next, $basis) * $daysPerYear;
602 } // function COUPDAYSNC()
603
604
638 public static function COUPNCD($settlement, $maturity, $frequency, $basis=0) {
639 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
640 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
641 $frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
642 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
643
644 if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
645 return PHPExcel_Calculation_Functions::VALUE();
646 }
647 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
648 return PHPExcel_Calculation_Functions::VALUE();
649 }
650
651 if (($settlement > $maturity) ||
652 (!self::_validFrequency($frequency)) ||
653 (($basis < 0) || ($basis > 4))) {
654 return PHPExcel_Calculation_Functions::NaN();
655 }
656
657 return self::_coupFirstPeriodDate($settlement, $maturity, $frequency, True);
658 } // function COUPNCD()
659
660
694 public static function COUPNUM($settlement, $maturity, $frequency, $basis=0) {
695 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
696 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
697 $frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
698 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
699
700 if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
701 return PHPExcel_Calculation_Functions::VALUE();
702 }
703 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
704 return PHPExcel_Calculation_Functions::VALUE();
705 }
706
707 if (($settlement > $maturity) ||
708 (!self::_validFrequency($frequency)) ||
709 (($basis < 0) || ($basis > 4))) {
710 return PHPExcel_Calculation_Functions::NaN();
711 }
712
713 $settlement = self::_coupFirstPeriodDate($settlement, $maturity, $frequency, True);
714 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis) * 365;
715
716 switch ($frequency) {
717 case 1: // annual payments
718 return ceil($daysBetweenSettlementAndMaturity / 360);
719 case 2: // half-yearly
720 return ceil($daysBetweenSettlementAndMaturity / 180);
721 case 4: // quarterly
722 return ceil($daysBetweenSettlementAndMaturity / 90);
723 case 6: // bimonthly
724 return ceil($daysBetweenSettlementAndMaturity / 60);
725 case 12: // monthly
726 return ceil($daysBetweenSettlementAndMaturity / 30);
727 }
728 return PHPExcel_Calculation_Functions::VALUE();
729 } // function COUPNUM()
730
731
765 public static function COUPPCD($settlement, $maturity, $frequency, $basis=0) {
766 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
767 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
768 $frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
769 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
770
771 if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
772 return PHPExcel_Calculation_Functions::VALUE();
773 }
774 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
775 return PHPExcel_Calculation_Functions::VALUE();
776 }
777
778 if (($settlement > $maturity) ||
779 (!self::_validFrequency($frequency)) ||
780 (($basis < 0) || ($basis > 4))) {
781 return PHPExcel_Calculation_Functions::NaN();
782 }
783
784 return self::_coupFirstPeriodDate($settlement, $maturity, $frequency, False);
785 } // function COUPPCD()
786
787
809 public static function CUMIPMT($rate, $nper, $pv, $start, $end, $type = 0) {
810 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
811 $nper = (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
812 $pv = PHPExcel_Calculation_Functions::flattenSingleValue($pv);
813 $start = (int) PHPExcel_Calculation_Functions::flattenSingleValue($start);
814 $end = (int) PHPExcel_Calculation_Functions::flattenSingleValue($end);
815 $type = (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
816
817 // Validate parameters
818 if ($type != 0 && $type != 1) {
819 return PHPExcel_Calculation_Functions::NaN();
820 }
821 if ($start < 1 || $start > $end) {
822 return PHPExcel_Calculation_Functions::VALUE();
823 }
824
825 // Calculate
826 $interest = 0;
827 for ($per = $start; $per <= $end; ++$per) {
828 $interest += self::IPMT($rate, $per, $nper, $pv, 0, $type);
829 }
830
831 return $interest;
832 } // function CUMIPMT()
833
834
856 public static function CUMPRINC($rate, $nper, $pv, $start, $end, $type = 0) {
857 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
858 $nper = (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
859 $pv = PHPExcel_Calculation_Functions::flattenSingleValue($pv);
860 $start = (int) PHPExcel_Calculation_Functions::flattenSingleValue($start);
861 $end = (int) PHPExcel_Calculation_Functions::flattenSingleValue($end);
862 $type = (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
863
864 // Validate parameters
865 if ($type != 0 && $type != 1) {
866 return PHPExcel_Calculation_Functions::NaN();
867 }
868 if ($start < 1 || $start > $end) {
869 return PHPExcel_Calculation_Functions::VALUE();
870 }
871
872 // Calculate
873 $principal = 0;
874 for ($per = $start; $per <= $end; ++$per) {
875 $principal += self::PPMT($rate, $per, $nper, $pv, 0, $type);
876 }
877
878 return $principal;
879 } // function CUMPRINC()
880
881
908 public static function DB($cost, $salvage, $life, $period, $month=12) {
909 $cost = PHPExcel_Calculation_Functions::flattenSingleValue($cost);
910 $salvage = PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
911 $life = PHPExcel_Calculation_Functions::flattenSingleValue($life);
912 $period = PHPExcel_Calculation_Functions::flattenSingleValue($period);
913 $month = PHPExcel_Calculation_Functions::flattenSingleValue($month);
914
915 // Validate
916 if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life)) && (is_numeric($period)) && (is_numeric($month))) {
917 $cost = (float) $cost;
918 $salvage = (float) $salvage;
919 $life = (int) $life;
920 $period = (int) $period;
921 $month = (int) $month;
922 if ($cost == 0) {
923 return 0.0;
924 } elseif (($cost < 0) || (($salvage / $cost) < 0) || ($life <= 0) || ($period < 1) || ($month < 1)) {
925 return PHPExcel_Calculation_Functions::NaN();
926 }
927 // Set Fixed Depreciation Rate
928 $fixedDepreciationRate = 1 - pow(($salvage / $cost), (1 / $life));
929 $fixedDepreciationRate = round($fixedDepreciationRate, 3);
930
931 // Loop through each period calculating the depreciation
932 $previousDepreciation = 0;
933 for ($per = 1; $per <= $period; ++$per) {
934 if ($per == 1) {
935 $depreciation = $cost * $fixedDepreciationRate * $month / 12;
936 } elseif ($per == ($life + 1)) {
937 $depreciation = ($cost - $previousDepreciation) * $fixedDepreciationRate * (12 - $month) / 12;
938 } else {
939 $depreciation = ($cost - $previousDepreciation) * $fixedDepreciationRate;
940 }
941 $previousDepreciation += $depreciation;
942 }
943 if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
944 $depreciation = round($depreciation,2);
945 }
946 return $depreciation;
947 }
948 return PHPExcel_Calculation_Functions::VALUE();
949 } // function DB()
950
951
975 public static function DDB($cost, $salvage, $life, $period, $factor=2.0) {
976 $cost = PHPExcel_Calculation_Functions::flattenSingleValue($cost);
977 $salvage = PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
978 $life = PHPExcel_Calculation_Functions::flattenSingleValue($life);
979 $period = PHPExcel_Calculation_Functions::flattenSingleValue($period);
980 $factor = PHPExcel_Calculation_Functions::flattenSingleValue($factor);
981
982 // Validate
983 if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life)) && (is_numeric($period)) && (is_numeric($factor))) {
984 $cost = (float) $cost;
985 $salvage = (float) $salvage;
986 $life = (int) $life;
987 $period = (int) $period;
988 $factor = (float) $factor;
989 if (($cost <= 0) || (($salvage / $cost) < 0) || ($life <= 0) || ($period < 1) || ($factor <= 0.0) || ($period > $life)) {
990 return PHPExcel_Calculation_Functions::NaN();
991 }
992 // Set Fixed Depreciation Rate
993 $fixedDepreciationRate = 1 - pow(($salvage / $cost), (1 / $life));
994 $fixedDepreciationRate = round($fixedDepreciationRate, 3);
995
996 // Loop through each period calculating the depreciation
997 $previousDepreciation = 0;
998 for ($per = 1; $per <= $period; ++$per) {
999 $depreciation = min( ($cost - $previousDepreciation) * ($factor / $life), ($cost - $salvage - $previousDepreciation) );
1000 $previousDepreciation += $depreciation;
1001 }
1002 if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
1003 $depreciation = round($depreciation,2);
1004 }
1005 return $depreciation;
1006 }
1007 return PHPExcel_Calculation_Functions::VALUE();
1008 } // function DDB()
1009
1010
1036 public static function DISC($settlement, $maturity, $price, $redemption, $basis=0) {
1037 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
1038 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
1039 $price = PHPExcel_Calculation_Functions::flattenSingleValue($price);
1040 $redemption = PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
1041 $basis = PHPExcel_Calculation_Functions::flattenSingleValue($basis);
1042
1043 // Validate
1044 if ((is_numeric($price)) && (is_numeric($redemption)) && (is_numeric($basis))) {
1045 $price = (float) $price;
1046 $redemption = (float) $redemption;
1047 $basis = (int) $basis;
1048 if (($price <= 0) || ($redemption <= 0)) {
1049 return PHPExcel_Calculation_Functions::NaN();
1050 }
1051 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
1052 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
1053 // return date error
1054 return $daysBetweenSettlementAndMaturity;
1055 }
1056
1057 return ((1 - $price / $redemption) / $daysBetweenSettlementAndMaturity);
1058 }
1059 return PHPExcel_Calculation_Functions::VALUE();
1060 } // function DISC()
1061
1062
1079 public static function DOLLARDE($fractional_dollar = Null, $fraction = 0) {
1080 $fractional_dollar = PHPExcel_Calculation_Functions::flattenSingleValue($fractional_dollar);
1081 $fraction = (int)PHPExcel_Calculation_Functions::flattenSingleValue($fraction);
1082
1083 // Validate parameters
1084 if (is_null($fractional_dollar) || $fraction < 0) {
1085 return PHPExcel_Calculation_Functions::NaN();
1086 }
1087 if ($fraction == 0) {
1088 return PHPExcel_Calculation_Functions::DIV0();
1089 }
1090
1091 $dollars = floor($fractional_dollar);
1092 $cents = fmod($fractional_dollar,1);
1093 $cents /= $fraction;
1094 $cents *= pow(10,ceil(log10($fraction)));
1095 return $dollars + $cents;
1096 } // function DOLLARDE()
1097
1098
1115 public static function DOLLARFR($decimal_dollar = Null, $fraction = 0) {
1116 $decimal_dollar = PHPExcel_Calculation_Functions::flattenSingleValue($decimal_dollar);
1117 $fraction = (int)PHPExcel_Calculation_Functions::flattenSingleValue($fraction);
1118
1119 // Validate parameters
1120 if (is_null($decimal_dollar) || $fraction < 0) {
1121 return PHPExcel_Calculation_Functions::NaN();
1122 }
1123 if ($fraction == 0) {
1124 return PHPExcel_Calculation_Functions::DIV0();
1125 }
1126
1127 $dollars = floor($decimal_dollar);
1128 $cents = fmod($decimal_dollar,1);
1129 $cents *= $fraction;
1130 $cents *= pow(10,-ceil(log10($fraction)));
1131 return $dollars + $cents;
1132 } // function DOLLARFR()
1133
1134
1150 public static function EFFECT($nominal_rate = 0, $npery = 0) {
1151 $nominal_rate = PHPExcel_Calculation_Functions::flattenSingleValue($nominal_rate);
1152 $npery = (int)PHPExcel_Calculation_Functions::flattenSingleValue($npery);
1153
1154 // Validate parameters
1155 if ($nominal_rate <= 0 || $npery < 1) {
1156 return PHPExcel_Calculation_Functions::NaN();
1157 }
1158
1159 return pow((1 + $nominal_rate / $npery), $npery) - 1;
1160 } // function EFFECT()
1161
1162
1185 public static function FV($rate = 0, $nper = 0, $pmt = 0, $pv = 0, $type = 0) {
1186 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
1187 $nper = PHPExcel_Calculation_Functions::flattenSingleValue($nper);
1188 $pmt = PHPExcel_Calculation_Functions::flattenSingleValue($pmt);
1189 $pv = PHPExcel_Calculation_Functions::flattenSingleValue($pv);
1190 $type = PHPExcel_Calculation_Functions::flattenSingleValue($type);
1191
1192 // Validate parameters
1193 if ($type != 0 && $type != 1) {
1194 return PHPExcel_Calculation_Functions::NaN();
1195 }
1196
1197 // Calculate
1198 if (!is_null($rate) && $rate != 0) {
1199 return -$pv * pow(1 + $rate, $nper) - $pmt * (1 + $rate * $type) * (pow(1 + $rate, $nper) - 1) / $rate;
1200 } else {
1201 return -$pv - $pmt * $nper;
1202 }
1203 } // function FV()
1204
1205
1219 public static function FVSCHEDULE($principal, $schedule) {
1220 $principal = PHPExcel_Calculation_Functions::flattenSingleValue($principal);
1221 $schedule = PHPExcel_Calculation_Functions::flattenArray($schedule);
1222
1223 foreach($schedule as $rate) {
1224 $principal *= 1 + $rate;
1225 }
1226
1227 return $principal;
1228 } // function FVSCHEDULE()
1229
1230
1253 public static function INTRATE($settlement, $maturity, $investment, $redemption, $basis=0) {
1254 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
1255 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
1256 $investment = PHPExcel_Calculation_Functions::flattenSingleValue($investment);
1257 $redemption = PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
1258 $basis = PHPExcel_Calculation_Functions::flattenSingleValue($basis);
1259
1260 // Validate
1261 if ((is_numeric($investment)) && (is_numeric($redemption)) && (is_numeric($basis))) {
1262 $investment = (float) $investment;
1263 $redemption = (float) $redemption;
1264 $basis = (int) $basis;
1265 if (($investment <= 0) || ($redemption <= 0)) {
1266 return PHPExcel_Calculation_Functions::NaN();
1267 }
1268 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
1269 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
1270 // return date error
1271 return $daysBetweenSettlementAndMaturity;
1272 }
1273
1274 return (($redemption / $investment) - 1) / ($daysBetweenSettlementAndMaturity);
1275 }
1276 return PHPExcel_Calculation_Functions::VALUE();
1277 } // function INTRATE()
1278
1279
1296 public static function IPMT($rate, $per, $nper, $pv, $fv = 0, $type = 0) {
1297 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
1298 $per = (int) PHPExcel_Calculation_Functions::flattenSingleValue($per);
1299 $nper = (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
1300 $pv = PHPExcel_Calculation_Functions::flattenSingleValue($pv);
1301 $fv = PHPExcel_Calculation_Functions::flattenSingleValue($fv);
1302 $type = (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
1303
1304 // Validate parameters
1305 if ($type != 0 && $type != 1) {
1306 return PHPExcel_Calculation_Functions::NaN();
1307 }
1308 if ($per <= 0 || $per > $nper) {
1309 return PHPExcel_Calculation_Functions::VALUE();
1310 }
1311
1312 // Calculate
1313 $interestAndPrincipal = self::_interestAndPrincipal($rate, $per, $nper, $pv, $fv, $type);
1314 return $interestAndPrincipal[0];
1315 } // function IPMT()
1316
1336 public static function IRR($values, $guess = 0.1) {
1337 if (!is_array($values)) return PHPExcel_Calculation_Functions::VALUE();
1338 $values = PHPExcel_Calculation_Functions::flattenArray($values);
1339 $guess = PHPExcel_Calculation_Functions::flattenSingleValue($guess);
1340
1341 // create an initial range, with a root somewhere between 0 and guess
1342 $x1 = 0.0;
1343 $x2 = $guess;
1344 $f1 = self::NPV($x1, $values);
1345 $f2 = self::NPV($x2, $values);
1346 for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
1347 if (($f1 * $f2) < 0.0) break;
1348 if (abs($f1) < abs($f2)) {
1349 $f1 = self::NPV($x1 += 1.6 * ($x1 - $x2), $values);
1350 } else {
1351 $f2 = self::NPV($x2 += 1.6 * ($x2 - $x1), $values);
1352 }
1353 }
1354 if (($f1 * $f2) > 0.0) return PHPExcel_Calculation_Functions::VALUE();
1355
1356 $f = self::NPV($x1, $values);
1357 if ($f < 0.0) {
1358 $rtb = $x1;
1359 $dx = $x2 - $x1;
1360 } else {
1361 $rtb = $x2;
1362 $dx = $x1 - $x2;
1363 }
1364
1365 for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
1366 $dx *= 0.5;
1367 $x_mid = $rtb + $dx;
1368 $f_mid = self::NPV($x_mid, $values);
1369 if ($f_mid <= 0.0)
1370 $rtb = $x_mid;
1371 if ((abs($f_mid) < FINANCIAL_PRECISION) || (abs($dx) < FINANCIAL_PRECISION))
1372 return $x_mid;
1373 }
1374 return PHPExcel_Calculation_Functions::VALUE();
1375 } // function IRR()
1376
1377
1394 public static function ISPMT() {
1395 // Return value
1396 $returnValue = 0;
1397
1398 // Get the parameters
1399 $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1400 $interestRate = array_shift($aArgs);
1401 $period = array_shift($aArgs);
1402 $numberPeriods = array_shift($aArgs);
1403 $principleRemaining = array_shift($aArgs);
1404
1405 // Calculate
1406 $principlePayment = ($principleRemaining * 1.0) / ($numberPeriods * 1.0);
1407 for($i=0; $i <= $period; ++$i) {
1408 $returnValue = $interestRate * $principleRemaining * -1;
1409 $principleRemaining -= $principlePayment;
1410 // principle needs to be 0 after the last payment, don't let floating point screw it up
1411 if($i == $numberPeriods) {
1412 $returnValue = 0;
1413 }
1414 }
1415 return($returnValue);
1416 } // function ISPMT()
1417
1418
1435 public static function MIRR($values, $finance_rate, $reinvestment_rate) {
1436 if (!is_array($values)) return PHPExcel_Calculation_Functions::VALUE();
1437 $values = PHPExcel_Calculation_Functions::flattenArray($values);
1438 $finance_rate = PHPExcel_Calculation_Functions::flattenSingleValue($finance_rate);
1439 $reinvestment_rate = PHPExcel_Calculation_Functions::flattenSingleValue($reinvestment_rate);
1440 $n = count($values);
1441
1442 $rr = 1.0 + $reinvestment_rate;
1443 $fr = 1.0 + $finance_rate;
1444
1445 $npv_pos = $npv_neg = 0.0;
1446 foreach($values as $i => $v) {
1447 if ($v >= 0) {
1448 $npv_pos += $v / pow($rr, $i);
1449 } else {
1450 $npv_neg += $v / pow($fr, $i);
1451 }
1452 }
1453
1454 if (($npv_neg == 0) || ($npv_pos == 0) || ($reinvestment_rate <= -1)) {
1455 return PHPExcel_Calculation_Functions::VALUE();
1456 }
1457
1458 $mirr = pow((-$npv_pos * pow($rr, $n))
1459 / ($npv_neg * ($rr)), (1.0 / ($n - 1))) - 1.0;
1460
1461 return (is_finite($mirr) ? $mirr : PHPExcel_Calculation_Functions::VALUE());
1462 } // function MIRR()
1463
1464
1474 public static function NOMINAL($effect_rate = 0, $npery = 0) {
1475 $effect_rate = PHPExcel_Calculation_Functions::flattenSingleValue($effect_rate);
1476 $npery = (int)PHPExcel_Calculation_Functions::flattenSingleValue($npery);
1477
1478 // Validate parameters
1479 if ($effect_rate <= 0 || $npery < 1) {
1480 return PHPExcel_Calculation_Functions::NaN();
1481 }
1482
1483 // Calculate
1484 return $npery * (pow($effect_rate + 1, 1 / $npery) - 1);
1485 } // function NOMINAL()
1486
1487
1500 public static function NPER($rate = 0, $pmt = 0, $pv = 0, $fv = 0, $type = 0) {
1501 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
1502 $pmt = PHPExcel_Calculation_Functions::flattenSingleValue($pmt);
1503 $pv = PHPExcel_Calculation_Functions::flattenSingleValue($pv);
1504 $fv = PHPExcel_Calculation_Functions::flattenSingleValue($fv);
1505 $type = PHPExcel_Calculation_Functions::flattenSingleValue($type);
1506
1507 // Validate parameters
1508 if ($type != 0 && $type != 1) {
1509 return PHPExcel_Calculation_Functions::NaN();
1510 }
1511
1512 // Calculate
1513 if (!is_null($rate) && $rate != 0) {
1514 if ($pmt == 0 && $pv == 0) {
1515 return PHPExcel_Calculation_Functions::NaN();
1516 }
1517 return log(($pmt * (1 + $rate * $type) / $rate - $fv) / ($pv + $pmt * (1 + $rate * $type) / $rate)) / log(1 + $rate);
1518 } else {
1519 if ($pmt == 0) {
1520 return PHPExcel_Calculation_Functions::NaN();
1521 }
1522 return (-$pv -$fv) / $pmt;
1523 }
1524 } // function NPER()
1525
1533 public static function NPV() {
1534 // Return value
1535 $returnValue = 0;
1536
1537 // Loop through arguments
1538 $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1539
1540 // Calculate
1541 $rate = array_shift($aArgs);
1542 for ($i = 1; $i <= count($aArgs); ++$i) {
1543 // Is it a numeric value?
1544 if (is_numeric($aArgs[$i - 1])) {
1545 $returnValue += $aArgs[$i - 1] / pow(1 + $rate, $i);
1546 }
1547 }
1548
1549 // Return
1550 return $returnValue;
1551 } // function NPV()
1552
1565 public static function PMT($rate = 0, $nper = 0, $pv = 0, $fv = 0, $type = 0) {
1566 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
1567 $nper = PHPExcel_Calculation_Functions::flattenSingleValue($nper);
1568 $pv = PHPExcel_Calculation_Functions::flattenSingleValue($pv);
1569 $fv = PHPExcel_Calculation_Functions::flattenSingleValue($fv);
1570 $type = PHPExcel_Calculation_Functions::flattenSingleValue($type);
1571
1572 // Validate parameters
1573 if ($type != 0 && $type != 1) {
1574 return PHPExcel_Calculation_Functions::NaN();
1575 }
1576
1577 // Calculate
1578 if (!is_null($rate) && $rate != 0) {
1579 return (-$fv - $pv * pow(1 + $rate, $nper)) / (1 + $rate * $type) / ((pow(1 + $rate, $nper) - 1) / $rate);
1580 } else {
1581 return (-$pv - $fv) / $nper;
1582 }
1583 } // function PMT()
1584
1585
1599 public static function PPMT($rate, $per, $nper, $pv, $fv = 0, $type = 0) {
1600 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
1601 $per = (int) PHPExcel_Calculation_Functions::flattenSingleValue($per);
1602 $nper = (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
1603 $pv = PHPExcel_Calculation_Functions::flattenSingleValue($pv);
1604 $fv = PHPExcel_Calculation_Functions::flattenSingleValue($fv);
1605 $type = (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
1606
1607 // Validate parameters
1608 if ($type != 0 && $type != 1) {
1609 return PHPExcel_Calculation_Functions::NaN();
1610 }
1611 if ($per <= 0 || $per > $nper) {
1612 return PHPExcel_Calculation_Functions::VALUE();
1613 }
1614
1615 // Calculate
1616 $interestAndPrincipal = self::_interestAndPrincipal($rate, $per, $nper, $pv, $fv, $type);
1617 return $interestAndPrincipal[1];
1618 } // function PPMT()
1619
1620
1621 public static function PRICE($settlement, $maturity, $rate, $yield, $redemption, $frequency, $basis=0) {
1622 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
1623 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
1624 $rate = (float) PHPExcel_Calculation_Functions::flattenSingleValue($rate);
1625 $yield = (float) PHPExcel_Calculation_Functions::flattenSingleValue($yield);
1626 $redemption = (float) PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
1627 $frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
1628 $basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
1629
1630 if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
1631 return PHPExcel_Calculation_Functions::VALUE();
1632 }
1633 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
1634 return PHPExcel_Calculation_Functions::VALUE();
1635 }
1636
1637 if (($settlement > $maturity) ||
1638 (!self::_validFrequency($frequency)) ||
1639 (($basis < 0) || ($basis > 4))) {
1640 return PHPExcel_Calculation_Functions::NaN();
1641 }
1642
1643 $dsc = self::COUPDAYSNC($settlement, $maturity, $frequency, $basis);
1644 $e = self::COUPDAYS($settlement, $maturity, $frequency, $basis);
1645 $n = self::COUPNUM($settlement, $maturity, $frequency, $basis);
1646 $a = self::COUPDAYBS($settlement, $maturity, $frequency, $basis);
1647
1648 $baseYF = 1.0 + ($yield / $frequency);
1649 $rfp = 100 * ($rate / $frequency);
1650 $de = $dsc / $e;
1651
1652 $result = $redemption / pow($baseYF, (--$n + $de));
1653 for($k = 0; $k <= $n; ++$k) {
1654 $result += $rfp / (pow($baseYF, ($k + $de)));
1655 }
1656 $result -= $rfp * ($a / $e);
1657
1658 return $result;
1659 } // function PRICE()
1660
1661
1681 public static function PRICEDISC($settlement, $maturity, $discount, $redemption, $basis=0) {
1682 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
1683 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
1684 $discount = (float) PHPExcel_Calculation_Functions::flattenSingleValue($discount);
1685 $redemption = (float) PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
1686 $basis = (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
1687
1688 // Validate
1689 if ((is_numeric($discount)) && (is_numeric($redemption)) && (is_numeric($basis))) {
1690 if (($discount <= 0) || ($redemption <= 0)) {
1691 return PHPExcel_Calculation_Functions::NaN();
1692 }
1693 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
1694 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
1695 // return date error
1696 return $daysBetweenSettlementAndMaturity;
1697 }
1698
1699 return $redemption * (1 - $discount * $daysBetweenSettlementAndMaturity);
1700 }
1701 return PHPExcel_Calculation_Functions::VALUE();
1702 } // function PRICEDISC()
1703
1704
1725 public static function PRICEMAT($settlement, $maturity, $issue, $rate, $yield, $basis=0) {
1726 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
1727 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
1728 $issue = PHPExcel_Calculation_Functions::flattenSingleValue($issue);
1729 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
1730 $yield = PHPExcel_Calculation_Functions::flattenSingleValue($yield);
1731 $basis = (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
1732
1733 // Validate
1734 if (is_numeric($rate) && is_numeric($yield)) {
1735 if (($rate <= 0) || ($yield <= 0)) {
1736 return PHPExcel_Calculation_Functions::NaN();
1737 }
1738 $daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
1739 if (!is_numeric($daysPerYear)) {
1740 return $daysPerYear;
1741 }
1742 $daysBetweenIssueAndSettlement = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $settlement, $basis);
1743 if (!is_numeric($daysBetweenIssueAndSettlement)) {
1744 // return date error
1745 return $daysBetweenIssueAndSettlement;
1746 }
1747 $daysBetweenIssueAndSettlement *= $daysPerYear;
1748 $daysBetweenIssueAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $maturity, $basis);
1749 if (!is_numeric($daysBetweenIssueAndMaturity)) {
1750 // return date error
1751 return $daysBetweenIssueAndMaturity;
1752 }
1753 $daysBetweenIssueAndMaturity *= $daysPerYear;
1754 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
1755 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
1756 // return date error
1757 return $daysBetweenSettlementAndMaturity;
1758 }
1759 $daysBetweenSettlementAndMaturity *= $daysPerYear;
1760
1761 return ((100 + (($daysBetweenIssueAndMaturity / $daysPerYear) * $rate * 100)) /
1762 (1 + (($daysBetweenSettlementAndMaturity / $daysPerYear) * $yield)) -
1763 (($daysBetweenIssueAndSettlement / $daysPerYear) * $rate * 100));
1764 }
1765 return PHPExcel_Calculation_Functions::VALUE();
1766 } // function PRICEMAT()
1767
1768
1781 public static function PV($rate = 0, $nper = 0, $pmt = 0, $fv = 0, $type = 0) {
1782 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
1783 $nper = PHPExcel_Calculation_Functions::flattenSingleValue($nper);
1784 $pmt = PHPExcel_Calculation_Functions::flattenSingleValue($pmt);
1785 $fv = PHPExcel_Calculation_Functions::flattenSingleValue($fv);
1786 $type = PHPExcel_Calculation_Functions::flattenSingleValue($type);
1787
1788 // Validate parameters
1789 if ($type != 0 && $type != 1) {
1790 return PHPExcel_Calculation_Functions::NaN();
1791 }
1792
1793 // Calculate
1794 if (!is_null($rate) && $rate != 0) {
1795 return (-$pmt * (1 + $rate * $type) * ((pow(1 + $rate, $nper) - 1) / $rate) - $fv) / pow(1 + $rate, $nper);
1796 } else {
1797 return -$fv - $pmt * $nper;
1798 }
1799 } // function PV()
1800
1801
1832 public static function RATE($nper, $pmt, $pv, $fv = 0.0, $type = 0, $guess = 0.1) {
1833 $nper = (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
1834 $pmt = PHPExcel_Calculation_Functions::flattenSingleValue($pmt);
1835 $pv = PHPExcel_Calculation_Functions::flattenSingleValue($pv);
1836 $fv = (is_null($fv)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($fv);
1837 $type = (is_null($type)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
1838 $guess = (is_null($guess)) ? 0.1 : PHPExcel_Calculation_Functions::flattenSingleValue($guess);
1839
1840 $rate = $guess;
1841 if (abs($rate) < FINANCIAL_PRECISION) {
1842 $y = $pv * (1 + $nper * $rate) + $pmt * (1 + $rate * $type) * $nper + $fv;
1843 } else {
1844 $f = exp($nper * log(1 + $rate));
1845 $y = $pv * $f + $pmt * (1 / $rate + $type) * ($f - 1) + $fv;
1846 }
1847 $y0 = $pv + $pmt * $nper + $fv;
1848 $y1 = $pv * $f + $pmt * (1 / $rate + $type) * ($f - 1) + $fv;
1849
1850 // find root by secant method
1851 $i = $x0 = 0.0;
1852 $x1 = $rate;
1853 while ((abs($y0 - $y1) > FINANCIAL_PRECISION) && ($i < FINANCIAL_MAX_ITERATIONS)) {
1854 $rate = ($y1 * $x0 - $y0 * $x1) / ($y1 - $y0);
1855 $x0 = $x1;
1856 $x1 = $rate;
1857 if (($nper * abs($pmt)) > ($pv - $fv))
1858 $x1 = abs($x1);
1859
1860 if (abs($rate) < FINANCIAL_PRECISION) {
1861 $y = $pv * (1 + $nper * $rate) + $pmt * (1 + $rate * $type) * $nper + $fv;
1862 } else {
1863 $f = exp($nper * log(1 + $rate));
1864 $y = $pv * $f + $pmt * (1 / $rate + $type) * ($f - 1) + $fv;
1865 }
1866
1867 $y0 = $y1;
1868 $y1 = $y;
1869 ++$i;
1870 }
1871 return $rate;
1872 } // function RATE()
1873
1874
1894 public static function RECEIVED($settlement, $maturity, $investment, $discount, $basis=0) {
1895 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
1896 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
1897 $investment = (float) PHPExcel_Calculation_Functions::flattenSingleValue($investment);
1898 $discount = (float) PHPExcel_Calculation_Functions::flattenSingleValue($discount);
1899 $basis = (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
1900
1901 // Validate
1902 if ((is_numeric($investment)) && (is_numeric($discount)) && (is_numeric($basis))) {
1903 if (($investment <= 0) || ($discount <= 0)) {
1904 return PHPExcel_Calculation_Functions::NaN();
1905 }
1906 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
1907 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
1908 // return date error
1909 return $daysBetweenSettlementAndMaturity;
1910 }
1911
1912 return $investment / ( 1 - ($discount * $daysBetweenSettlementAndMaturity));
1913 }
1914 return PHPExcel_Calculation_Functions::VALUE();
1915 } // function RECEIVED()
1916
1917
1928 public static function SLN($cost, $salvage, $life) {
1929 $cost = PHPExcel_Calculation_Functions::flattenSingleValue($cost);
1930 $salvage = PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
1931 $life = PHPExcel_Calculation_Functions::flattenSingleValue($life);
1932
1933 // Calculate
1934 if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life))) {
1935 if ($life < 0) {
1936 return PHPExcel_Calculation_Functions::NaN();
1937 }
1938 return ($cost - $salvage) / $life;
1939 }
1940 return PHPExcel_Calculation_Functions::VALUE();
1941 } // function SLN()
1942
1943
1955 public static function SYD($cost, $salvage, $life, $period) {
1956 $cost = PHPExcel_Calculation_Functions::flattenSingleValue($cost);
1957 $salvage = PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
1958 $life = PHPExcel_Calculation_Functions::flattenSingleValue($life);
1959 $period = PHPExcel_Calculation_Functions::flattenSingleValue($period);
1960
1961 // Calculate
1962 if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life)) && (is_numeric($period))) {
1963 if (($life < 1) || ($period > $life)) {
1964 return PHPExcel_Calculation_Functions::NaN();
1965 }
1966 return (($cost - $salvage) * ($life - $period + 1) * 2) / ($life * ($life + 1));
1967 }
1968 return PHPExcel_Calculation_Functions::VALUE();
1969 } // function SYD()
1970
1971
1984 public static function TBILLEQ($settlement, $maturity, $discount) {
1985 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
1986 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
1987 $discount = PHPExcel_Calculation_Functions::flattenSingleValue($discount);
1988
1989 // Use TBILLPRICE for validation
1990 $testValue = self::TBILLPRICE($settlement, $maturity, $discount);
1991 if (is_string($testValue)) {
1992 return $testValue;
1993 }
1994
1995 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
1996 return PHPExcel_Calculation_Functions::VALUE();
1997 }
1998
1999 if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
2000 ++$maturity;
2001 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity) * 360;
2002 } else {
2003 $daysBetweenSettlementAndMaturity = (PHPExcel_Calculation_DateTime::_getDateValue($maturity) - PHPExcel_Calculation_DateTime::_getDateValue($settlement));
2004 }
2005
2006 return (365 * $discount) / (360 - $discount * $daysBetweenSettlementAndMaturity);
2007 } // function TBILLEQ()
2008
2009
2022 public static function TBILLPRICE($settlement, $maturity, $discount) {
2023 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
2024 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
2025 $discount = PHPExcel_Calculation_Functions::flattenSingleValue($discount);
2026
2027 if (is_string($maturity = PHPExcel_Calculation_DateTime::_getDateValue($maturity))) {
2028 return PHPExcel_Calculation_Functions::VALUE();
2029 }
2030
2031 // Validate
2032 if (is_numeric($discount)) {
2033 if ($discount <= 0) {
2034 return PHPExcel_Calculation_Functions::NaN();
2035 }
2036
2037 if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
2038 ++$maturity;
2039 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity) * 360;
2040 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
2041 // return date error
2042 return $daysBetweenSettlementAndMaturity;
2043 }
2044 } else {
2045 $daysBetweenSettlementAndMaturity = (PHPExcel_Calculation_DateTime::_getDateValue($maturity) - PHPExcel_Calculation_DateTime::_getDateValue($settlement));
2046 }
2047
2048 if ($daysBetweenSettlementAndMaturity > 360) {
2049 return PHPExcel_Calculation_Functions::NaN();
2050 }
2051
2052 $price = 100 * (1 - (($discount * $daysBetweenSettlementAndMaturity) / 360));
2053 if ($price <= 0) {
2054 return PHPExcel_Calculation_Functions::NaN();
2055 }
2056 return $price;
2057 }
2058 return PHPExcel_Calculation_Functions::VALUE();
2059 } // function TBILLPRICE()
2060
2061
2074 public static function TBILLYIELD($settlement, $maturity, $price) {
2075 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
2076 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
2077 $price = PHPExcel_Calculation_Functions::flattenSingleValue($price);
2078
2079 // Validate
2080 if (is_numeric($price)) {
2081 if ($price <= 0) {
2082 return PHPExcel_Calculation_Functions::NaN();
2083 }
2084
2085 if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
2086 ++$maturity;
2087 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity) * 360;
2088 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
2089 // return date error
2090 return $daysBetweenSettlementAndMaturity;
2091 }
2092 } else {
2093 $daysBetweenSettlementAndMaturity = (PHPExcel_Calculation_DateTime::_getDateValue($maturity) - PHPExcel_Calculation_DateTime::_getDateValue($settlement));
2094 }
2095
2096 if ($daysBetweenSettlementAndMaturity > 360) {
2097 return PHPExcel_Calculation_Functions::NaN();
2098 }
2099
2100 return ((100 - $price) / $price) * (360 / $daysBetweenSettlementAndMaturity);
2101 }
2102 return PHPExcel_Calculation_Functions::VALUE();
2103 } // function TBILLYIELD()
2104
2105
2106 public static function XIRR($values, $dates, $guess = 0.1) {
2107 if ((!is_array($values)) && (!is_array($dates))) return PHPExcel_Calculation_Functions::VALUE();
2108 $values = PHPExcel_Calculation_Functions::flattenArray($values);
2109 $dates = PHPExcel_Calculation_Functions::flattenArray($dates);
2110 $guess = PHPExcel_Calculation_Functions::flattenSingleValue($guess);
2111 if (count($values) != count($dates)) return PHPExcel_Calculation_Functions::NaN();
2112
2113 // create an initial range, with a root somewhere between 0 and guess
2114 $x1 = 0.0;
2115 $x2 = $guess;
2116 $f1 = self::XNPV($x1, $values, $dates);
2117 $f2 = self::XNPV($x2, $values, $dates);
2118 for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
2119 if (($f1 * $f2) < 0.0) break;
2120 if (abs($f1) < abs($f2)) {
2121 $f1 = self::XNPV($x1 += 1.6 * ($x1 - $x2), $values, $dates);
2122 } else {
2123 $f2 = self::XNPV($x2 += 1.6 * ($x2 - $x1), $values, $dates);
2124 }
2125 }
2126 if (($f1 * $f2) > 0.0) return PHPExcel_Calculation_Functions::VALUE();
2127
2128 $f = self::XNPV($x1, $values, $dates);
2129 if ($f < 0.0) {
2130 $rtb = $x1;
2131 $dx = $x2 - $x1;
2132 } else {
2133 $rtb = $x2;
2134 $dx = $x1 - $x2;
2135 }
2136
2137 for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
2138 $dx *= 0.5;
2139 $x_mid = $rtb + $dx;
2140 $f_mid = self::XNPV($x_mid, $values, $dates);
2141 if ($f_mid <= 0.0) $rtb = $x_mid;
2142 if ((abs($f_mid) < FINANCIAL_PRECISION) || (abs($dx) < FINANCIAL_PRECISION)) return $x_mid;
2143 }
2144 return PHPExcel_Calculation_Functions::VALUE();
2145 }
2146
2147
2162 public static function XNPV($rate, $values, $dates) {
2163 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
2164 if (!is_numeric($rate)) return PHPExcel_Calculation_Functions::VALUE();
2165 if ((!is_array($values)) || (!is_array($dates))) return PHPExcel_Calculation_Functions::VALUE();
2166 $values = PHPExcel_Calculation_Functions::flattenArray($values);
2167 $dates = PHPExcel_Calculation_Functions::flattenArray($dates);
2168 $valCount = count($values);
2169 if ($valCount != count($dates)) return PHPExcel_Calculation_Functions::NaN();
2170 if ((min($values) > 0) || (max($values) < 0)) return PHPExcel_Calculation_Functions::VALUE();
2171
2172 $xnpv = 0.0;
2173 for ($i = 0; $i < $valCount; ++$i) {
2174 if (!is_numeric($values[$i])) return PHPExcel_Calculation_Functions::VALUE();
2175 $xnpv += $values[$i] / pow(1 + $rate, PHPExcel_Calculation_DateTime::DATEDIF($dates[0],$dates[$i],'d') / 365);
2176 }
2177 return (is_finite($xnpv)) ? $xnpv : PHPExcel_Calculation_Functions::VALUE();
2178 } // function XNPV()
2179
2180
2200 public static function YIELDDISC($settlement, $maturity, $price, $redemption, $basis=0) {
2201 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
2202 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
2203 $price = PHPExcel_Calculation_Functions::flattenSingleValue($price);
2204 $redemption = PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
2205 $basis = (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
2206
2207 // Validate
2208 if (is_numeric($price) && is_numeric($redemption)) {
2209 if (($price <= 0) || ($redemption <= 0)) {
2210 return PHPExcel_Calculation_Functions::NaN();
2211 }
2212 $daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
2213 if (!is_numeric($daysPerYear)) {
2214 return $daysPerYear;
2215 }
2216 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity,$basis);
2217 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
2218 // return date error
2219 return $daysBetweenSettlementAndMaturity;
2220 }
2221 $daysBetweenSettlementAndMaturity *= $daysPerYear;
2222
2223 return (($redemption - $price) / $price) * ($daysPerYear / $daysBetweenSettlementAndMaturity);
2224 }
2225 return PHPExcel_Calculation_Functions::VALUE();
2226 } // function YIELDDISC()
2227
2228
2249 public static function YIELDMAT($settlement, $maturity, $issue, $rate, $price, $basis=0) {
2250 $settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
2251 $maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
2252 $issue = PHPExcel_Calculation_Functions::flattenSingleValue($issue);
2253 $rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
2254 $price = PHPExcel_Calculation_Functions::flattenSingleValue($price);
2255 $basis = (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
2256
2257 // Validate
2258 if (is_numeric($rate) && is_numeric($price)) {
2259 if (($rate <= 0) || ($price <= 0)) {
2260 return PHPExcel_Calculation_Functions::NaN();
2261 }
2262 $daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
2263 if (!is_numeric($daysPerYear)) {
2264 return $daysPerYear;
2265 }
2266 $daysBetweenIssueAndSettlement = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $settlement, $basis);
2267 if (!is_numeric($daysBetweenIssueAndSettlement)) {
2268 // return date error
2269 return $daysBetweenIssueAndSettlement;
2270 }
2271 $daysBetweenIssueAndSettlement *= $daysPerYear;
2272 $daysBetweenIssueAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $maturity, $basis);
2273 if (!is_numeric($daysBetweenIssueAndMaturity)) {
2274 // return date error
2275 return $daysBetweenIssueAndMaturity;
2276 }
2277 $daysBetweenIssueAndMaturity *= $daysPerYear;
2278 $daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
2279 if (!is_numeric($daysBetweenSettlementAndMaturity)) {
2280 // return date error
2281 return $daysBetweenSettlementAndMaturity;
2282 }
2283 $daysBetweenSettlementAndMaturity *= $daysPerYear;
2284
2285 return ((1 + (($daysBetweenIssueAndMaturity / $daysPerYear) * $rate) - (($price / 100) + (($daysBetweenIssueAndSettlement / $daysPerYear) * $rate))) /
2286 (($price / 100) + (($daysBetweenIssueAndSettlement / $daysPerYear) * $rate))) *
2287 ($daysPerYear / $daysBetweenSettlementAndMaturity);
2288 }
2289 return PHPExcel_Calculation_Functions::VALUE();
2290 } // function YIELDMAT()
2291
2292} // class PHPExcel_Calculation_Financial
$result
$result
Definition: CleanUpTest.php:407
FINANCIAL_PRECISION
const FINANCIAL_PRECISION
FINANCIAL_PRECISION.
Definition: Financial.php:43
FINANCIAL_MAX_ITERATIONS
const FINANCIAL_MAX_ITERATIONS(!defined('PHPEXCEL_ROOT'))
PHPExcel root directory.
Definition: Financial.php:40
$n
$n
Definition: RandomTest.php:80
php
An exception for terminatinating execution or to throw for unit testing.
PHPExcel_Calculation_DateTime\YEAR
static YEAR($dateValue=1)
YEAR.
Definition: DateTime.php:1253
PHPExcel_Calculation_DateTime\DATEDIF
static DATEDIF($startDate=0, $endDate=0, $unit='D')
DATEDIF.
Definition: DateTime.php:618
PHPExcel_Calculation_DateTime\_isLeapYear
static _isLeapYear($year)
Identify if a year is a leap year or not.
Definition: DateTime.php:54
PHPExcel_Calculation_DateTime\YEARFRAC
static YEARFRAC($startDate=0, $endDate=0, $method=0)
Definition: DateTime.php:791
PHPExcel_Calculation_DateTime\_getDateValue
static _getDateValue($dateValue)
_getDateValue
Definition: DateTime.php:101
PHPExcel_Calculation_Financial
Definition: Financial.php:53
PHPExcel_Calculation_Financial\_lastDayOfMonth
static _lastDayOfMonth($testDate)
_lastDayOfMonth
Definition: Financial.php:63
PHPExcel_Calculation_Financial\XIRR
static XIRR($values, $dates, $guess=0.1)
Definition: Financial.php:2106
PHPExcel_Calculation_Financial\CUMIPMT
static CUMIPMT($rate, $nper, $pv, $start, $end, $type=0)
Definition: Financial.php:809
PHPExcel_Calculation_Financial\_interestAndPrincipal
static _interestAndPrincipal($rate=0, $per=0, $nper=0, $pv=0, $fv=0, $type=0)
Definition: Financial.php:153
PHPExcel_Calculation_Financial\DISC
static DISC($settlement, $maturity, $price, $redemption, $basis=0)
Definition: Financial.php:1036
PHPExcel_Calculation_Financial\COUPPCD
static COUPPCD($settlement, $maturity, $frequency, $basis=0)
Definition: Financial.php:765
PHPExcel_Calculation_Financial\IRR
static IRR($values, $guess=0.1)
IRR.
Definition: Financial.php:1336
PHPExcel_Calculation_Financial\NPV
static NPV()
NPV.
Definition: Financial.php:1533
PHPExcel_Calculation_Financial\IPMT
static IPMT($rate, $per, $nper, $pv, $fv=0, $type=0)
IPMT.
Definition: Financial.php:1296
PHPExcel_Calculation_Financial\_validFrequency
static _validFrequency($frequency)
Definition: Financial.php:105
PHPExcel_Calculation_Financial\SLN
static SLN($cost, $salvage, $life)
SLN.
Definition: Financial.php:1928
PHPExcel_Calculation_Financial\_daysPerYear
static _daysPerYear($year, $basis=0)
_daysPerYear
Definition: Financial.php:132
PHPExcel_Calculation_Financial\YIELDMAT
static YIELDMAT($settlement, $maturity, $issue, $rate, $price, $basis=0)
YIELDMAT.
Definition: Financial.php:2249
PHPExcel_Calculation_Financial\_coupFirstPeriodDate
static _coupFirstPeriodDate($settlement, $maturity, $frequency, $next)
Definition: Financial.php:83
PHPExcel_Calculation_Financial\TBILLPRICE
static TBILLPRICE($settlement, $maturity, $discount)
TBILLPRICE.
Definition: Financial.php:2022
PHPExcel_Calculation_Financial\ISPMT
static ISPMT()
ISPMT.
Definition: Financial.php:1394
PHPExcel_Calculation_Financial\EFFECT
static EFFECT($nominal_rate=0, $npery=0)
Definition: Financial.php:1150
PHPExcel_Calculation_Financial\AMORLINC
static AMORLINC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis=0)
Definition: Financial.php:385
PHPExcel_Calculation_Financial\DDB
static DDB($cost, $salvage, $life, $period, $factor=2.0)
Definition: Financial.php:975
PHPExcel_Calculation_Financial\PRICE
static PRICE($settlement, $maturity, $rate, $yield, $redemption, $frequency, $basis=0)
Definition: Financial.php:1621
PHPExcel_Calculation_Financial\ACCRINTM
static ACCRINTM($issue, $settlement, $rate, $par=1000, $basis=0)
Definition: Financial.php:253
PHPExcel_Calculation_Financial\DB
static DB($cost, $salvage, $life, $period, $month=12)
Definition: Financial.php:908
PHPExcel_Calculation_Financial\XNPV
static XNPV($rate, $values, $dates)
XNPV.
Definition: Financial.php:2162
PHPExcel_Calculation_Financial\RECEIVED
static RECEIVED($settlement, $maturity, $investment, $discount, $basis=0)
RECEIVED.
Definition: Financial.php:1894
PHPExcel_Calculation_Financial\TBILLEQ
static TBILLEQ($settlement, $maturity, $discount)
TBILLEQ.
Definition: Financial.php:1984
PHPExcel_Calculation_Financial\INTRATE
static INTRATE($settlement, $maturity, $investment, $redemption, $basis=0)
INTRATE.
Definition: Financial.php:1253
PHPExcel_Calculation_Financial\PRICEDISC
static PRICEDISC($settlement, $maturity, $discount, $redemption, $basis=0)
PRICEDISC.
Definition: Financial.php:1681
PHPExcel_Calculation_Financial\FVSCHEDULE
static FVSCHEDULE($principal, $schedule)
FVSCHEDULE.
Definition: Financial.php:1219
PHPExcel_Calculation_Financial\RATE
static RATE($nper, $pmt, $pv, $fv=0.0, $type=0, $guess=0.1)
Definition: Financial.php:1832
PHPExcel_Calculation_Financial\COUPNCD
static COUPNCD($settlement, $maturity, $frequency, $basis=0)
Definition: Financial.php:638
PHPExcel_Calculation_Financial\COUPDAYSNC
static COUPDAYSNC($settlement, $maturity, $frequency, $basis=0)
Definition: Financial.php:579
PHPExcel_Calculation_Financial\PRICEMAT
static PRICEMAT($settlement, $maturity, $issue, $rate, $yield, $basis=0)
PRICEMAT.
Definition: Financial.php:1725
PHPExcel_Calculation_Financial\FV
static FV($rate=0, $nper=0, $pmt=0, $pv=0, $type=0)
Definition: Financial.php:1185
PHPExcel_Calculation_Financial\NOMINAL
static NOMINAL($effect_rate=0, $npery=0)
NOMINAL.
Definition: Financial.php:1474
PHPExcel_Calculation_Financial\TBILLYIELD
static TBILLYIELD($settlement, $maturity, $price)
TBILLYIELD.
Definition: Financial.php:2074
PHPExcel_Calculation_Financial\MIRR
static MIRR($values, $finance_rate, $reinvestment_rate)
MIRR.
Definition: Financial.php:1435
PHPExcel_Calculation_Financial\COUPDAYS
static COUPDAYS($settlement, $maturity, $frequency, $basis=0)
Definition: Financial.php:509
PHPExcel_Calculation_Financial\PMT
static PMT($rate=0, $nper=0, $pv=0, $fv=0, $type=0)
PMT.
Definition: Financial.php:1565
PHPExcel_Calculation_Financial\YIELDDISC
static YIELDDISC($settlement, $maturity, $price, $redemption, $basis=0)
YIELDDISC.
Definition: Financial.php:2200
PHPExcel_Calculation_Financial\DOLLARFR
static DOLLARFR($decimal_dollar=Null, $fraction=0)
Definition: Financial.php:1115
PHPExcel_Calculation_Financial\AMORDEGRC
static AMORDEGRC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis=0)
Definition: Financial.php:309
PHPExcel_Calculation_Financial\ACCRINT
static ACCRINT($issue, $firstinterest, $settlement, $rate, $par=1000, $frequency=1, $basis=0)
Definition: Financial.php:201
PHPExcel_Calculation_Financial\PPMT
static PPMT($rate, $per, $nper, $pv, $fv=0, $type=0)
PPMT.
Definition: Financial.php:1599
PHPExcel_Calculation_Financial\COUPDAYBS
static COUPDAYBS($settlement, $maturity, $frequency, $basis=0)
Definition: Financial.php:451
PHPExcel_Calculation_Financial\PV
static PV($rate=0, $nper=0, $pmt=0, $fv=0, $type=0)
PV.
Definition: Financial.php:1781
PHPExcel_Calculation_Financial\CUMPRINC
static CUMPRINC($rate, $nper, $pv, $start, $end, $type=0)
Definition: Financial.php:856
PHPExcel_Calculation_Financial\SYD
static SYD($cost, $salvage, $life, $period)
SYD.
Definition: Financial.php:1955
PHPExcel_Calculation_Financial\COUPNUM
static COUPNUM($settlement, $maturity, $frequency, $basis=0)
Definition: Financial.php:694
PHPExcel_Calculation_Financial\NPER
static NPER($rate=0, $pmt=0, $pv=0, $fv=0, $type=0)
NPER.
Definition: Financial.php:1500
PHPExcel_Calculation_Financial\_firstDayOfMonth
static _firstDayOfMonth($testDate)
_firstDayOfMonth
Definition: Financial.php:77
PHPExcel_Calculation_Financial\DOLLARDE
static DOLLARDE($fractional_dollar=Null, $fraction=0)
Definition: Financial.php:1079
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC
const COMPATIBILITY_GNUMERIC
Definition: Functions.php:63
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE
const COMPATIBILITY_OPENOFFICE
Definition: Functions.php:64
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
PHPExcel_Shared_Date\PHPToExcel
static PHPToExcel($dateValue=0, $adjustToTimezone=FALSE, $timezone=NULL)
Convert a date from PHP to Excel.
Definition: Date.php:185
PHPExcel_Shared_Date\ExcelToPHPObject
static ExcelToPHPObject($dateValue=0)
Convert a date from Excel to a PHP Date/Time object.
Definition: Date.php:160
$y
$y
Definition: example_007.php:83
e
e($cmd)
Definition: flush.php:14
defined
defined( 'APPLICATION_ENV')||define( 'APPLICATION_ENV'
Definition: bootstrap.php:27