IRR算法

 
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
 
public class IrrUtil {
    private double MINDIF = 0.001;
 
    private int LOOPNUM = 2000;
 
    private static int period = 0;  
 
    @SuppressWarnings("rawtypes")
    private List netCash = new ArrayList();  
 
    
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(-76694086.73);
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(9184579.93 );
        list.add(184579.93 );
        
        IrrUtil  aa = new IrrUtil(list,12);
        System.out.println(aa.calculator());
    }
    @SuppressWarnings("rawtypes")
    public IrrUtil(List netCashArr, int interval) {
        super();
        netCash = netCashArr;
        period = 12/interval;
    }
 
    private double NPV(double r) {
 
        double npv = 0;
 
        if (netCash.size() != 0) {
            for (int count = 0; count < netCash.size(); count++) {
                npv += Double.valueOf(netCash.get(count).toString()) / Math.pow(1 + r, count);
            }
            return npv;
        }
        return null;
    }
 
    public double calculator() {
 
        double irr = 0;
        double r1 = new BigDecimal("0.1").doubleValue();
        double r2 = new BigDecimal("0.09").doubleValue();
        double npv1 = NPV(r1);
        double npv2 = NPV(r2);
        //System.out.println(netCash+"--");
        int count = 0;
        while (Math.abs(npv2) > MINDIF & count < LOOPNUM) {
            irr = r2 - npv2 * (r2 - r1) / (npv2 - npv1);
            r1 = r2;
            r2 = irr;
            npv1 = npv2;
            npv2 = NPV(r2);
            count++;
            // System.out.println(count+"--");
        }
        // System.out.println(irr*period+"--");
        if (Math.abs(npv2) < MINDIF & count <= LOOPNUM)
 
            //return irr * period ;
            return irr;
        else
            return null;
    }
}
转载:https://blog.csdn.net/cs_19_dn/article/details/53287781

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
IRRR(Internal Rate of Return Recursive)算法是一种计算投资回报率的方法。在Java中实现IRR算法可以使用迭代法或者二分法,下面是一个使用迭代法实现IRR算法的示例代码: ```java public class IRRAlgorithm { private static final double EPSILON = 0.00001; // 定义精度 public static double calculateIRR(double[] cashFlows) { double irr = 0.1; // 初始IRR值,可以根据实际情况进行调整 while (true) { double npv = calculateNPV(cashFlows, irr); double derivative = calculateDerivative(cashFlows, irr); double newIRR = irr - npv / derivative; // 根据迭代公式计算新的IRR值 if (Math.abs(newIRR - irr) < EPSILON) { return newIRR; } irr = newIRR; } } private static double calculateNPV(double[] cashFlows, double rate) { double npv = 0; for (int i = 0; i < cashFlows.length; i++) { npv += cashFlows[i] / Math.pow(1 + rate, i + 1); } return npv; } private static double calculateDerivative(double[] cashFlows, double rate) { double derivative = 0; for (int i = 0; i < cashFlows.length; i++) { derivative -= (i + 1) * cashFlows[i] / Math.pow(1 + rate, i + 2); } return derivative; } public static void main(String[] args) { double[] cashFlows = {-100, 50, 40, 30}; // 这里假设有一个投资项目,初始投资为-100,后续收益为50, 40, 30 double irr = calculateIRR(cashFlows); System.out.println("IRR: " + irr); } } ``` 以上代码通过迭代法计算给定现金流的IRR值。在`calculateIRR`方法中,通过不断迭代计算新的IRR值,直到新旧IRR之间的差值小于设定的精度阈值(EPSILON),然后返回最终的IRR值。 在`calculateNPV`方法中,计算现金流的净现值(Net Present Value,NPV),通过将每个现金流按照时间加权求和的方式计算得到。 在`calculateDerivative`方法中,计算IRR对于NPV的导数,用于迭代过程中更新IRR值。 最后,在`main`方法中定义了一个示例现金流数组`cashFlows`,并调用`calculateIRR`方法计算并输出IRR值。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值