Return the items in between the passed in index
and the end of the array.

Luc.Array.fromIndex([1,2,3,4,5], 1)
>[2, 3, 4, 5]

@param  {Array/arguments} arr
@param  {Number} index
@return {Array} the new array.
329447
function fromIndex(a, index) {
    var arr = is.isArguments(a) ? arraySlice.call(a) : a;
    return arraySlice.call(arr, index, arr.length);
}
291489
public static INDArrayIndex[] allFor(INDArray arr) {
        INDArrayIndex[] ret = new INDArrayIndex[arr.rank()];
        for (int i = 0; i < ret.length; i++)
            ret[i] = NDArrayIndex.all();

        return ret;
    }
759926
function _findIndex(arr, onFind) {
  let foundIndex = -1;

  util.forEach(arr, (item, index) => {
    let nextFind = true;
    if (onFind(item, index)) {
      foundIndex = index;
      nextFind = false;
    }

    return nextFind;
  });

  return foundIndex;
}
471209
public static Object get(Object array, int index) {

    return java.lang.reflect.Array.get(array, index);
  }
578951
function swapArrayElements(items, indexFrom, indexTo) {
  var item = items[indexTo];
  items[indexTo] = items[indexFrom];
  items[indexFrom] = item;
  return items;
}
1141746
function(index) {
    return function(array) {
      if ((index < 0) || (index > array.length - 1)) L.fail("L.nth failure: attempting to index outside the bounds of the given array.");
      return array[index];
    };
  }
567062
function arrayToList(array) {
  if(isArray(array)) {
    return List.fromArray(array)
  }
  else if(isFunction(array)) {
    return function(x) {
      const g = array(x)

      if(!isArray(g)) {
        throw new TypeError('arrayToList: Array returning function required')
      }

      return List.fromArray(g)
    }
  }

  throw new TypeError('arrayToList: Array or Array returning function required')
}
1072772
function(arr) {
      var n = [], l=arr.length,i;
      for(i = 0 ; i < l ; i++) {
         if( !lang.isNull(arr[i]) && !lang.isUndefined(arr[i]) ) {
            n.push(arr[i]);
         }
      }
      return n;
   }
939401
function(array) {
            var ln = array.length,
                newAry = [];
            for (var i = 0; i < ln; i++) {
                if (jsonQ.index(newAry, array[i]) == -1) {
                    newAry.push(array[i]);
                }
            }
            return newAry;
        }
1118659
function(arr, iterator) {
  var i = arr.length - 1, index = null

  if(i >= 0){
    do {
      if(iterator(arr[i])) {
        index = i
        break
      }
    } while(i--)
  }

  return index
}
839366
function subIndex(arr, index) {
  if (!Array.isArray(arr)) {
    var arrType = typeof arr;
    var stringifiedArr = String(arr);

    throw new TypeError(
      'Expected an array, but got ' +
      (stringifiedArr === arrType ? stringifiedArr : stringifiedArr + ' (' + arrType + ')') +
      '.'
    );
  }

  if (arr.length === 0) {
    throw new Error('Expected a non-empty array, but got [].');
  }

  var indexType = typeof index;
  var stringifiedIndex = String(index);

  if (indexType !== 'number') {
    throw new TypeError(
      'Expected an index of array (integer), but got ' +
      (stringifiedIndex === indexType ? stringifiedIndex : stringifiedIndex + ' (' + indexType + ')') +
      '.'
    );
  }

  if (!isFinite(index) || Math.floor(index) !== index) {
    throw new Error('Expected an index of array (integer), but got ' + String(index) + '.');
  }

  if (index < 0) {
    throw new Error('Expected an index of array (positive integer), but got ' + String(index) + '.');
  }

  var arrLength = arr.length;

  if (index >= arrLength) {
    throw new Error(
      'Expected an index of array, but got ' +
      String(index) +
      ' that exceeds the last index of the array (' + (arrLength - 1) + ').');
  }

  if (arr.length === 1) {
    return null;
  }

  if (index === 0) {
    return 1;
  }

  return index - 1;
}
72580
function(arr) {
        if (Array.prototype.from) return Array.from(new Set(arr));
        return arr.filter(function(v,i,a) {
          return i === a.indexOf(v);
        });
      }
1183052
def from_array(cls, arr, index=None, name=None, copy=False,
                   fill_value=None, fastpath=False):
        
        warnings.warn("'from_array' is deprecated and will be removed in a "
                      "future version. Please use the pd.SparseSeries(..) "
                      "constructor instead.", FutureWarning, stacklevel=2)
        return cls(arr, index=index, name=name, copy=copy,
                   fill_value=fill_value, fastpath=fastpath)
789935
public static Object getElementFromArrary(Object array, int index) {
    try {
      return Array.get(array, index);
    } catch (ArrayIndexOutOfBoundsException e) {
      return null;
    }
  }
1212968
function (index) {
        var split = false;
        var arrayOperationIndex, arrayOperation,
            arrayOperationRangeStart, arrayOperationRangeEnd,
            len;

        // OPTIMIZE: we could search these faster if we kept a balanced tree.
        // find leftmost arrayOperation to the right of `index`
        for (arrayOperationIndex = arrayOperationRangeStart = 0, len = this._operations.length; arrayOperationIndex < len; ++arrayOperationIndex) {
          arrayOperation = this._operations[arrayOperationIndex];

          if (arrayOperation.type === DELETE) { continue; }

          arrayOperationRangeEnd = arrayOperationRangeStart + arrayOperation.count - 1;

          if (index === arrayOperationRangeStart) {
            break;
          } else if (index > arrayOperationRangeStart && index <= arrayOperationRangeEnd) {
            split = true;
            break;
          } else {
            arrayOperationRangeStart = arrayOperationRangeEnd + 1;
          }
        }

        return new ArrayOperationMatch(arrayOperation, arrayOperationIndex, split, arrayOperationRangeStart);
      }
80784
function _arraySlice(start, end, arr) {
    var len = arr.length;
    var range = [];
    start = idx(len, start);
    end = idx(len, end, len);
    while (start < end) {
        range.push(arr[start++]);
    }
    return range;
    function idx(len, pos, end) {
        if (end === void 0) { end = undefined; }
        if (pos == null) {
            pos = end || 0;
        }
        else if (pos < 0) {
            pos = Math.max(len + pos, 0);
        }
        else {
            pos = Math.min(pos, len);
        }
        return pos;
    }
}
800747
function(arr, value) {
        var inx = arr.indexOf(value);
        var endIndex = arr.length - 1;
        if (inx !== endIndex) {
            var temp = arr[endIndex];
            arr[endIndex] = arr[inx];
            arr[inx] = temp;
        }
        arr.pop();
    }