Sets the multipliers of the AtomContainers.

@param  newMultipliers  The new multipliers for the AtomContainers in this set
@return                 true if multipliers have been set.
@see                    #getMultipliers
334156
@Override
    public boolean setMultipliers(Double[] newMultipliers) {
        if (newMultipliers.length == atomContainerCount) {
            if (multipliers == null) {
                multipliers = new Double[atomContainerCount];
            }
            System.arraycopy(newMultipliers, 0, multipliers, 0, atomContainerCount);
            notifyChanged();
            return true;
        }

        return false;
    }
906385
public final void multiplyValues(double multiplier) {
        for(Map.Entry<Object, Object> entry : internalData.entrySet()) {
            Double previousValue = TypeInference.toDouble(entry.getValue());
            if(previousValue==null) {
                continue;
            }
            internalData.put(entry.getKey(), previousValue*multiplier);
        } 
    }
612965
@Override
    public Iterable<IAtomContainer> atomContainers() {
        return new Iterable<IAtomContainer>() {

            @Override
            public Iterator<IAtomContainer> iterator() {
                return new AtomContainerIterator();
            }
        };
    }
485723
public boolean addAll(DoubleArray items) {
    ensureCapacity(size + items.size);
    for (int i = 0; i < items.size; i++) {
      elements[size++] = items.elements[i];
    }
    return items.size > 0;
  }
868322
@SuppressWarnings("unchecked")
    public void setSwitchers(Switcher<T>[] switchers) {
        if (switchers != null && switchers.length > 0
                && this.switchers != null && this.switchers.length > 0) {
            Switcher<T>[] oldSwitchers = this.switchers;
            this.switchers = new Switcher[oldSwitchers.length + switchers.length];
            System.arraycopy(oldSwitchers, 0, this.switchers, 0, oldSwitchers.length);
            System.arraycopy(switchers, 0, this.switchers, oldSwitchers.length, switchers.length);
        } else {
            this.switchers = switchers;
        }
    }
272923
private boolean increment(TridentCollector[] lengths, int[] indices, int j) {
        if (j == -1)
            return false;
        indices[j]++;
        CaptureCollector capturer = (CaptureCollector) lengths[j];
        if (indices[j] >= capturer.captured.size()) {
            indices[j] = 0;
            return increment(lengths, indices, j - 1);
        }
        return true;
    }
160961
@Override
    public DescriptorValue calculate(IAtomContainer atomContainer) {

        int n = 0; // count all heavy atom - heavy atom bonds
        for (IBond bond : atomContainer.bonds()) {
            if (bond.getBegin().getAtomicNumber() != 1 && bond.getEnd().getAtomicNumber() != 1) {
                n++;
            }
        }

        double vadjMa = 0;
        if (n > 0) {
            vadjMa += (Math.log(n) / Math.log(2)) + 1;
        }
        return new DescriptorValue(getSpecification(), getParameterNames(), getParameters(), new DoubleResult(vadjMa),
                getDescriptorNames());
    }
186846
public void setScopes(java.util.Collection<Scope> scopes) {
        if (scopes == null) {
            this.scopes = null;
            return;
        }

        this.scopes = new java.util.ArrayList<Scope>(scopes);
    }
448305
private boolean nodeOnMultipleRacks(Collection<DatanodeDescriptor> nodes) {
    DatanodeDescriptor previous = null;
    for (DatanodeDescriptor node : nodes) {
      if (previous != null && !previous.getNetworkLocation().equals(node.getNetworkLocation())) {
        return true;
      }
      previous = node;
    }
    return false;
  }
1036712
public static boolean hasCrystalCoordinates(IAtomContainer container) {
        Iterator<IAtom> atoms = container.atoms().iterator();
        while (atoms.hasNext()) {
            if (atoms.next().getFractionalPoint3d() == null) {
                return false;
            }
        }
        return true;
    }
598061
public void setSystem(ParticleSystem system) {
		this.system = system;
		emitters.clear();
		system.setRemoveCompletedEmitters(false);
		for (int i = 0; i < system.getEmitterCount(); i++) {
			emitters.add(system.getEmitter(i));
		}
	}
287667
public DockerContainerObjectBuilder<T> withEnrichers(Collection<TestEnricher> enrichers) {
        if (enrichers == null) {
            throw new IllegalArgumentException("enrichers cannot be null");
        }
        this.enrichers = enrichers;
        return this;
    }
681709
private static boolean isRingSystemSproutedWithNonRingDoubleBonds(IAtomContainer fullContainer,
            IAtomContainer isolatedRingSystem) {
        Iterator<IAtom> atoms = isolatedRingSystem.atoms().iterator();
        while (atoms.hasNext()) {
            IAtom atom = atoms.next();
            Iterator<IBond> neighborBonds = fullContainer.getConnectedBondsList(atom).iterator();
            while (neighborBonds.hasNext()) {
                IBond neighborBond = neighborBonds.next();
                if (!neighborBond.getFlag(CDKConstants.ISINRING)
                        && neighborBond.getOrder() == Order.DOUBLE
                        || neighborBond.getOrder() == Order.TRIPLE) {
                    if (!("N.sp2.3".equals(atom.getAtomTypeName()) && "O.sp2".equals(neighborBond
                                                                                         .getOther(atom).getAtomTypeName()))) return true;
                }
            }
        }
        return false;
    }
628751
@Override
    public void setAtoms(IAtom[] atoms) {
        this.atoms = atoms;
        atomCount = atoms.length;
        notifyChanged();
    }
970463
public static <K, V> SetMultimap<K, V> newConcurrentSetMultimap(Supplier<Set<V>> valueSupplier) {
        return new SetMultimap<K, V>(ConcurrentHashMap::new, valueSupplier, null);
    }
148599
private IAtomContainer setFlags(IAtomContainer container, IAtomContainer ac, boolean b) {
        for (Iterator<IAtom> it = container.atoms().iterator(); it.hasNext();) {
            int positionA = ac.indexOf(it.next());
            ac.getAtom(positionA).setFlag(CDKConstants.REACTIVE_CENTER, b);
        }
        for (Iterator<IBond> it = container.bonds().iterator(); it.hasNext();) {
            int positionB = ac.indexOf(it.next());
            ac.getBond(positionB).setFlag(CDKConstants.REACTIVE_CENTER, b);

        }
        return ac;
    }
511392
BigInteger setMultiChoiceCount() {
    if (fields != null)
      for (int i = 0; i < fields.length; i++)
        multiChoiceCount = multiChoiceCount.multiply(fields[i].setMultiChoiceCount());
    return multiChoiceCount;
  }