npm's personal messenger

    node-irr
    TypeScript icon, indicating that this package has built-in type declarations

    2.0.3 • Public • Published

    node-irr

    A Node.js package that provides an easy and customizable way to calculate internal rate of return.

    Installation

    # using yarn 
    yarn add node-irr
     
    # using npm 
    npm install node-irr --save

    Usage

    IRR

    const irr: (values: number[], options?: RootFinderOptions) => number
    const { irr } = require('node-irr')
    const data = [-10, -10, 21]
     
    console.log(irr(data))
    // -> 0.03297097167558927
    // -> ~3.29%

    XIRR

    const xirr: (inputs: XirrInput[], options?: RootFinderOptions) => { days: number, rate: number }
    const { xirr } = require('node-irr')
    const data = [
      // currently accepted formats for strings:
      // YYYYMMDD, YYYY-MM-DD, YYYY/MM/DD
      { amount: -10, date: '20180101' },
      { amount: 10, date: '20180201' },
      { amount: 0.05, date: '20180301' },
    ]
    // or
    const data = [
      { amount: -10, date: new Date(2018, 0, 1) },
      { amount: 10, date: new Date(2018, 1, 1) },
      { amount: 0.05, date: new Date(2018, 2, 1) },
    ]
     
    console.log(xirr(data))
    // -> { days: 60, rate: 0.0001601831164046441 }
    //                      ^^^^^^^^^^^^^^^^^^^^^ -> daily rate
    // -> ~0.016% per day
    // -> ~6.02% per year

    Using Options

    options.epsilon

    • type: number
    • default: 10-8
    • description: Maximum acceptable absolute distance between exact root (x0) and approximate root (λ), |x0 - λ| < ε.

    options.estimate

    • type: number | 'auto'
    • default: 'auto'
    • description: Used as the initial value for the Newton Method (RootFinderMethod.Newton).

    options.fallbackMethod

    • type: RootFinderMethod
    • default: RootFinderMethod.Newton ('newton')
    • description: Method to use to find the root.

    options.maxIterations

    • type: number
    • default: 100
    • description: Number of iterations to go through before stopping if an acceptable approximated root is not found.
    options.method
    • type: RootFinderMethod
    • default: RootFinderMethod.Bisection ('bisection')
    • description: Method to use to find the root if the primary one (options.method) fails.

    Newton vs Bisection

    The Newton Method (1) is considerably faster in number of iterations than the Bisection Method (2), but sometimes fails depending on the initial estimate, which is why (1) is used as the primary method, and (2) as a fallback.

    Helper Functions

    convertRate

    export enum RateInterval {
      Day = 'day',
      Week = 'week',
      Month = 'month',
      Year = 'year',
    }
    const convertRate: (rate: number, toInterval: RateInterval | number, fromInterval: RateInterval | number = RateInterval.Day) => number
    const { convertRate } = require('node-irr')
     
    const rate = 0.0004 // ~ 0.04% (day)
    const annualRate = convertRate(rate, 'year') // ~15.7%
    // or
    const annualRate = convertRate(rate, 365) // ~15.7%

    Install

    npm i node-irr

    DownloadsWeekly Downloads

    3,346

    Version

    2.0.3

    License

    MIT

    Unpacked Size

    104 kB

    Total Files

    66

    Last publish

    Collaborators

    • eric-malachias