Calculate the size to cycle width based on the sum of all items up to but not including the defined index.

@param {Number} index    - Includes the clone index
@returns {Number}
@private
438760
function(index) {
        var sum = 0;

        $.each(this._sizes, function(i, value) {
            if (i < index) {
                sum += value.totalSize;
            }
        });

        return sum;
    }
1005143
public int getAttributeSize(int index) {
        final VertexAttribute attribute = getAttribute(index);
        if (attribute == null) {
            return -1;
        }
        return attribute.getSize();
    }
268417
function(item,index){
    var _self = this,
      type = item.type || _self._getDefaultType(),
      cons = _self._getSeriesClass(type),
      cfg = _self._getSeriesCfg(type,item,index),
      series ;
    cfg.autoPaint = cfg.autoPaint || false;

    series  = _self.addGroup(cons,cfg);
    
    return series;
  }
33477
public static int getCatalogIndexSize(Index index) {
        int indexSize = 0;
        String jsonstring = index.getExpressionsjson();

        if (jsonstring.isEmpty()) {
            indexSize = getSortedCatalogItems(index.getColumns(), "index").size();
        } else {
            try {
                indexSize = AbstractExpression.fromJSONArrayString(jsonstring, null).size();
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        return indexSize;
    }
1080956
def _sumindex(self, index=None):
        """"""
        try:
            ndim = len(index)
        except TypeError:
            # turn index into a 1-tuple
            index = (index,)
            ndim = 1
        if len(self.shape) != ndim:
            raise ValueError("Index to %d-dimensional array %s has too %s dimensions" %
                (len(self.shape), self.name, ["many","few"][len(self.shape) > ndim]))
        sumindex = 0
        for i in range(ndim-1,-1,-1):
            index1 = index[i]
            if index1 < 0 or index1 >= self.shape[i]:
                raise ValueError("Dimension %d index for array %s is out of bounds (value=%d)" %
                    (i+1, self.name, index1))
            sumindex = index1 + sumindex*self.shape[i]
        return sumindex
817540
def calculate_size(name, index):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += INT_SIZE_IN_BYTES
    return data_size
388960
function stringSize(string) {
      if (!(string && reHasComplexSymbol.test(string))) {
        return string.length;
      }
      var result = reComplexSymbol.lastIndex = 0;
      while (reComplexSymbol.test(string)) {
        result++;
      }
      return result;
    }
806028
function setup (index) {
  function get () {
    return this[ArrayIndex.get](index);
  }
  function set (v) {
    return this[ArrayIndex.set](index, v);
  }
  return {
    enumerable: true,
    configurable: true,
    get: get,
    set: set
  };
}
482818
function(index) {

            var segments = this.segments;
            var numSegments = segments.length;
            if (numSegments === 0) throw new Error('Path has no segments.');

            if (index < 0) index = numSegments + index; // convert negative indices to positive
            if (index >= numSegments || index < 0) throw new Error('Index out of range.');

            return segments[index];
        }
838181
def sizeHint(self, option, index):
        
        size = super(XTreeWidgetDelegate, self).sizeHint(option, index)
        
        tree = self.parent()
        item = tree.itemFromIndex(index)
        
        try:
            fixed_height = item.fixedHeight()
        except:
            fixed_height = 0
        
        if fixed_height:
            size.setHeight(fixed_height)
        
        return size
945122
function(val) {
      return val === undefined ? (this.length ? this[0].clientWidth || this[0].innerWidth : 0) : this.each(function(index, el) {
        el.style.width = val + 'px';
      });
    }
1166314
function getter (index) {
  debug('getting array[%d]', index)
  var size = this.constructor.BYTES_PER_ELEMENT
  var baseType = this.constructor.type
  var offset = size * index
  var end = offset + size
  var buffer = this.buffer
  if (buffer.length < end) {
    debug('reinterpreting buffer from %d to %d', buffer.length, end)
    buffer = _ref.reinterpret(buffer, end)
  }
  return _ref.get(buffer, offset, baseType)
}
625165
function findLargestInRow (M, i) {
  // get the row:
  const m = M.elements;
  const n = M.dimension;
  const offset = i;

  let j = 0;
  let lrgElem = _Math.abs(m[offset]);
  let lrgCol = j;
  for (j = 1; j < n; ++j) {
    const val = _Math.abs(m[offset + j * n]);
    if (val > lrgElem) {
      lrgCol = j;
      lrgElem = val;
    }
  }
  return lrgCol;
}
605042
function getChildAt(index) {
         if (index >= 0 && index < this.children.length) {
           return this.children[index];
         } else {
           throw new Error("Index (" + index + ") Out Of Bounds for getChildAt()");
         }
       }
780116
function(index){
    
        //check for out-of-bounds values
        if (index > -1 && index < this._length){
            var current = this._head,
                i = 0;
                
            while(i++ < index){
                current = current.next;            
            }
        
            return current.data;
        } else {
            return null;
        }
    }
848385
def get_size(self, chrom=None):
        
        if len(self.size) == 0:
            raise LookupError("no chromosomes in index, is the index correct?")

        if chrom:
            if chrom in self.size:
                return self.size[chrom]
            else: 
                raise KeyError("chromosome {} not in index".format(chrom))
        total = 0
        for size in self.size.values():
            total += size

        return total
361633
function (index) {
                    index = asNumber(index);
                    var item = this.getItem(index);
                    return item && item.key;
                }