Utility functions to calculate percentiles and percent ranks in a JavaScript array.

percentile.js

// Returns the value at a given percentile in a sorted numeric array.
// "Linear interpolation between closest ranks" method
function percentile(arr, p) {
    if (arr.length === 0) return 0;
    if (typeof p !== 'number') throw new TypeError('p must be a number');
    if (p <= 0) return arr[0];
    if (p >= 1) return arr[arr.length - 1];

    var index = (arr.length - 1) * p,
        lower = Math.floor(index),
        upper = lower + 1,
        weight = index % 1;

    if (upper >= arr.length) return arr[lower];
    return arr[lower] * (1 - weight) + arr[upper] * weight;
}

// Returns the percentile of the given value in a sorted numeric array.
function percentRank(arr, v) {
    if (typeof v !== 'number') throw new TypeError('v must be a number');
    for (var i = 0, l = arr.length; i < l; i++) {
        if (v <= arr[i]) {
            while (i < l && v === arr[i]) i++;
            if (i === 0) return 0;
            if (v !== arr[i-1]) {
                i += (v - arr[i-1]) / (arr[i] - arr[i-1]);
            }
            return i / l;
        }
    }
    return 1;
}

I've ported the function rank method from numpy's percentileofscore.

• Docs of percentileofscore
• Original implementation

You need to have ramda as dependency, but chances are if you need this function, you already use ramda to facilitate functional programming:

const R = require('ramda')
const percentileOfScore = (array, value) => {
  let originalLength = array.length
  let a = [...array]
  let alen
  const equalsValue = v => v === value

  if (!R.any(equalsValue, array)) {
    a.push(value)
    alen = range(a.length)
  } else {
    alen = range(a.length + 1)
  }
  const sortedArray = R.sort((a, b) => a - b, array)
  const idx = R.map(equalsValue, sortedArray)
  const alenTrue = R.filter((v, i) => {
    return idx[alen.indexOf(v)] === true
  }, alen)
  const mean = R.mean(alenTrue)
  const percent = mean / originalLength
  return percent
}

@superzadeh Thanks for the function! Here's modified version that uses Lodash (to get the mean) and it expects array to be already sorted (to avoid n * sorting):

const percentileOfScore = (array, value) => {
    const originalLength = array.length;
    const a = [...array];
    let alen;
    const equalsValue = v => v === value;

    if (!array.some(equalsValue)) {
        a.push(value);
        alen = range(a.length)
    } else {
        alen = range(a.length + 1)
    }
    const idx = array.map(equalsValue);
    const alenTrue = alen.filter((v) => idx[alen.indexOf(v)]);
    const meanVal = mean(alenTrue);
    const percent = meanVal / originalLength;
    return Math.round( percent * 100) / 100;
};

I don't know why I didn't see all these comments for years, but thanks for the contributions. I updated line 9.

---

// sort + filter by open interest
  {
    filteredBacktestResults.sort((a, b) => a.open_interest - b.open_interest)
    const values = filteredBacktestResults.map(backtestResult => backtestResult.open_interest)
    for (let i = 0; i < filteredBacktestResults.length; ++i) {
      filteredBacktestResults[i].open_interest_rank_percentile = percentRank(values, filteredBacktestResults[i].open_interest)
    }
    filteredBacktestResults = filteredBacktestResults.filter(backtestResult => {
      const openInterestTooLow = backtestResult.open_interest_rank_percentile <= 0.25 // bottom 25%
      if (openInterestTooLow === true) {
        return false
      }
      return true
    })
  }

hopefully this example helps somebody else on Google of how to use this, thank you @IceCreamYou + others who helped make it better