Finds the position of other components.
@param others a non-null list of components
420043
private void dealWithOthers( Collection<AbstractType> others ) {

		int col = 1;
		this.currentWidth = this.hMargin;
		for( AbstractType t : others ) {

			if( col > this.maxPerLine ) {
				col = 1;
				this.currentHeigth += V_PADDING + GraphUtils.SHAPE_HEIGHT;
				this.currentWidth = this.hMargin;
			}

			this.typeToLocation.put( t, new Point2D.Double( this.currentWidth, this.currentHeigth ));
			this.currentWidth += H_PADDING + GraphUtils.computeShapeWidth( t );
			col ++;

			this.maxRowWidth = Math.max( this.maxRowWidth, this.currentWidth );
		}

		if( others.size() == 1 )
			this.aloneOnRow.add( others.iterator().next());
	}
177133
public boolean areDimensionsLeftAligned(int[] otherDims) {
    for (int i = 0; i < otherDims.length; i++) {
      if (otherDims[i] != dimensions[i]) {
        return false;
      }
    }
    return true;
  }
683095
public void set(IntDoubleSortedVector other) {
        this.used = other.used;
        this.indices = IntArrays.copyOf(other.indices);
        this.values = DoubleArrays.copyOf(other.values);
    }
1166587
public boolean overlaps(Span other) {
      return other != null && this.start() < other.end() && this.end() > other.start();
   }
888154
public boolean contains(String name) {
        if (name == null) {
            throw new IllegalArgumentException("Other cannot be null");
        }

        if (this.name.equals(name)) {
            return true;
        }

        if (hasReferences()) {
            for (Marker ref : referenceList) {
                if (ref.contains(name)) {
                    return true;
                }
            }
        }
        return false;
    }
35226
public void set(VTensor other) {
        checkEqualSize(this, other);
        this.dims = IntArrays.copyOf(other.dims);
        for (int c = 0; c < this.size(); c++) {
            this.setValue(c, other.getValue(c));
        }
    }
1198781
function findComponents(nodes, callback) {
  nodes = toArray(nodes);
  nodes = [].slice.call(nodes);
  var node;

  for (var i = 0, l = nodes.length; i < l; i++) {
    node = nodes[i];

    if (node && node.hasAttribute && node.hasAttribute('data-component')) {
      callback(node);
    } else if (node.childNodes && node.childNodes.length) {
      findComponents([].slice.call(node.childNodes), callback);
    }
  }
}
155811
def get_individual_positions(individuals):
    
    ind_pos = {}
    if individuals:
        for i, ind in enumerate(individuals):
            ind_pos[ind] = i
    return ind_pos
1137480
def get_component_product(self, other):
        """"""
        return Point(self.x * other.x, self.y * other.y)
784191
public void set(IntFloatSortedVector other) {
        this.used = other.used;
        this.indices = IntArrays.copyOf(other.indices);
        this.values = FloatArrays.copyOf(other.values);
    }
692872
public void combine(SpdLong other) {
        if (other == null)
            return;
        if (stat.isEnabled() && other.isEnabled())
            stat.combine((CountStatisticImpl) other.getStatistic());
    }
1054544
public boolean isDisplayed(String other) {
        return (getDisplay() == null || getDisplay().compareTo("all") == 0 || getDisplay().indexOf(other) != -1);
    }
986773
public synchronized void incrAllCounters(Counters other) {
    for(Map.Entry<String, CounterGroup> rightEntry: other.groups.entrySet()) {
      CounterGroup left = groups.get(rightEntry.getKey());
      CounterGroup right = rightEntry.getValue();
      if (left == null) {
        left = new CounterGroup(right.getName(), right.getDisplayName());
        groups.put(rightEntry.getKey(), left);
      }
      left.incrAllCounters(right);
    }
  }
187192
public static <T extends IPositioned & ISized, U extends IPositioned & ISized> IPosition leftOf(ISized owner, U other, int spacing)
	{
		return of(Positions.leftOf(owner, other, spacing), middleAlignedTo(owner, other, 0));
	}
111235
public void elemSubtract(VTensor other) {
        checkEqualSize(this, other);
        for (int c = 0; c < this.size(); c++) {
            subtractValue(c, other.getValue(c));
        }
    }
931603
public static <T extends IPositioned & ISized> IntSupplier bottomAlignedTo(ISized owner, T other, int offset)
	{

		checkNotNull(other);
		return () -> {
			return other.position().y() + other.size().height() - owner.size().height() + offset;
		};

	}
1178496
public void meetWith(LockSet other) {
        for (int i = 0; i + 1 < array.length; i += 2) {
            int valueNumber = array[i];
            if (valueNumber < 0) {
                break;
            }

            int mine = array[i + 1];
            int his = other.getLockCount(valueNumber);
            array[i + 1] = mergeValues(mine, his);
        }

        for (int i = 0; i + 1 < other.array.length; i += 2) {
            int valueNumber = other.array[i];
            if (valueNumber < 0) {
                break;
            }

            int mine = getLockCount(valueNumber);
            int his = other.array[i + 1];
            setLockCount(valueNumber, mergeValues(mine, his));
        }

        setDefaultLockCount(0);
    }