Calculates the absolute sizes of all of the children of this Item.
@returns {object} - Set with absolute sizes and additional pixels.
556914
function() {
		var i,
			totalSplitterSize = (this.contentItems.length - 1) * this._splitterSize,
  		headerSize = this.layoutManager.config.dimensions.headerHeight,
			totalWidth = this.element.width(),
			totalHeight = this.element.height(),
			totalAssigned = 0,
			additionalPixel,
			itemSize,
			itemSizes = [];

		if( this._isColumn ) {
			totalHeight -= totalSplitterSize;
		} else {
			totalWidth -= totalSplitterSize;
		}
		for( i = 0; i < this.contentItems.length; i++ ) {
			if( this._isDocked( i ) )
				if( this._isColumn ) {
					totalHeight -= headerSize - this._splitterSize;
				} else {
					totalWidth -= headerSize - this._splitterSize;
				}
		}

		for( i = 0; i < this.contentItems.length; i++ ) {
			if( this._isColumn ) {
				itemSize = Math.floor( totalHeight * ( this.contentItems[ i ].config.height / 100 ) );
			} else {
				itemSize = Math.floor( totalWidth * (this.contentItems[ i ].config.width / 100) );
			}
			if( this._isDocked( i ) )
				itemSize = headerSize;

			totalAssigned += itemSize;
			itemSizes.push( itemSize );
		}

		additionalPixel = Math.floor( (this._isColumn ? totalHeight : totalWidth) - totalAssigned );

		return {
			itemSizes: itemSizes,
			additionalPixel: additionalPixel,
			totalWidth: totalWidth,
			totalHeight: totalHeight
		};
	}
1305655
def size(self):
        """"""
        if self.children:
            return sum( ( c.size() for c in self.children.values() ) ) + 1
        else:
            return 1
591599
function() {
        var area = 0.0;
        for (var i=0, len=this.components.length; i<len; i++) {
            area += this.components[i].getArea();
        }
        return area;
    }
272683
public int size()
    {
        int ret = 0;
        for(Collection<LineSeriesItem<I,V>> series : data)
        {
            if(series.size() > 0)
                ++ret;
        }
        return ret;
    }
1169871
function() {
			var element = this._.element.getFirst();
			return { width: element.$.offsetWidth || 0, height: element.$.offsetHeight || 0 };
		}
1114986
function() {
		var allContentItems = [];

		var addChildren = function( contentItem ) {
			allContentItems.push( contentItem );

			if( contentItem.contentItems instanceof Array ) {
				for( var i = 0; i < contentItem.contentItems.length; i++ ) {
					addChildren( contentItem.contentItems[ i ] );
				}
			}
		};

		addChildren( this.root );

		return allContentItems;
	}
956350
function () {
                    var rect = this._anchorElement.getBoundingClientRect();

                    return {
                        x: rect.left,
                        y: rect.top,
                        width: rect.width,
                        height: rect.height
                    };
                }
956677
public int size() {
        // Since the sets are disjoint, we can simple sum their sizes
        int size = 0;
        for (Set<T> s : sets)
            size += s.size();
        return size;
    }
451327
function() {
    var m = 0, n = this.elements.length, k = n, i;
    do { i = k - n;
      if (Math.abs(this.elements[i]) > Math.abs(m)) { m = this.elements[i]; }
    } while (--n);
    return m;
  }
40908
public function getSize()
    {
        $size = 1;
        foreach ($this->getChildren() as $child) {
            $size += $child->getSize();
        }

        return $size;
    }
404815
function calculateExpansions() {
    let impl = function(expansions, parentStart, parentLevel) {
        expansions.forEach((expansion, index) => {
            expansion._level = parentLevel;

            // We need to calculate the start position of this expansion. The start
            // position isn't just the offset of the item relative to the parent, but
            // also takes into account expanded items above it. 
            //
            // One easy way to do this is to just check the previous item and get its end index.
            // We fetch the one on the same level not above or below. That should in theory
            // already have a start/end relative to the parent. If there isn't a previous sibling
            // then we will take the parent start value. Add onto this the offset for the item
            // and we've got our starting value.
            //
            // eg. 
            //   Item 1 <-- start 0, end 0
            //   Item 2 <-- start 2, end 8
            //       Item 2.1 <-- start 3, end 3
            //          Item 2.1.1
            //       Item 2.2
            //       Item 2.3 <-- start 6, end 6
            //          Item 2.3.1
            //       Item 2.4 <-- start 8, end 8
            //          Item 2.4.1 
            //   Item 3
            //   Item 4 <-- start 11, end 12
            //       Item 4.1
            //       Item 4.2
            let start, end;
            let prevSibling = expansions[index - 1];
            if (prevSibling) {
                start = prevSibling._end + 1 + (expansion.offset - prevSibling.offset);
            } else {
                start = parentStart + 1 + expansion.offset;
            }

            expansion._start = start;

            // To calculate the ending, we recursively add the children
            // for this expansion, and that will be added to the start value.
            let totalChildren = expansion.children;
            forEachExpansion(expansion.expansions, (expansion) => {
                totalChildren += expansion.children;
            });

            // We add the children and substract one. We subtract one because
            // the start is one of the children.
            expansion._end = expansion._start + totalChildren - 1;

            // Repeat this recursively for all of the nested expansions.
            // The nested expansions will have a relative start to this 
            // expansion.
            impl(expansion.expansions, expansion._start, parentLevel + 1);
        });
    }

    impl(_(this).expansions, -1, 0);
}
518708
def all_children_count
      size = subsegments.count
      subsegments.each { |v| size += v.all_children_count }
      size
    end
594099
function() {
            var d = 1 / (this.m[0] * this.m[3] - this.m[1] * this.m[2]);
            var m0 = this.m[3] * d;
            var m1 = -this.m[1] * d;
            var m2 = -this.m[2] * d;
            var m3 = this.m[0] * d;
            var m4 = d * (this.m[2] * this.m[5] - this.m[3] * this.m[4]);
            var m5 = d * (this.m[1] * this.m[4] - this.m[0] * this.m[5]);
            this.m[0] = m0;
            this.m[1] = m1;
            this.m[2] = m2;
            this.m[3] = m3;
            this.m[4] = m4;
            this.m[5] = m5;
            return this;
        }
1279853
function(items) {
            for(var i = 0; i < items.length; i++) {
                var height = items[i].element[0].getBoundingClientRect().height;
                var relPosDiff = items[i].diffWithNextRelativePos;
                var ratio = 0;
                if(!isNaN(height) && !isNaN(relPosDiff))
                    ratio = height / relPosDiff;

                items[i].relativePosRatio = ratio;
            }
        }
1362264
public int size()
    {
        int size = 0;
        if (value != null)
            size++;
        for (Trie<K, V> child : children.values())
            size += child.size();
        return size;
    }
282803
function(element) {
        if(!element) return;

        var children = element.children();
        if(children.length <= 0) return;

        var totalWidth = 0;
        for(var i = 0; i < children.length; i++) {
            totalWidth += $(children[i]).width();
        }

        element.width(totalWidth);
    }
290289
function (dimensions) {
                return {
                    x: this.limitRoles.includes('left') ? 0 : dimensions.width - this.width / 2,
                    y: this.limitRoles.includes('top') ? 0 : dimensions.height - this.height / 2
                };
            }