Returns a tuple with the specified size, containing
all zeros.

@param size The size
@return The zero tuple.
@throws IllegalArgumentException If the size is smaller than 0
540386
public static LongTuple zero(int size)
    {
        if (size >= 0 && size < ZERO_POOL_SIZE)
        {
            return ZEROS[size];
        }
        return createZero(size);
    }
19924
private static String getLeadingZeros(int i, int size)
	{
		assert i <= size;
		int w1 = (int) Math.floor(Math.log10(size));
		int w2 = (int) Math.floor(Math.log10(i));
		
		String s = "";

		for (int j = w2; j < w1; j++)
		{
			s += "0";
		}
		return s;
	}
788278
public int size() {
		int size = 0;
		for (List<V> value : map.values()) {
			size += value.size();
		}
		return size;
	}
1360381
@Factory
    public static <E> Matcher<? super Collection<? extends E>> hasSize(Matcher<? super Integer> size) {
        return new IsCollectionWithSize<E>(size);
    }
281688
protected byte[] getBuffer(int size) {
    byte[] buffer;
    if (size > SERIALIZER_BUFFER_SIZE) {
      buffer = new byte[size];
    } else {
      buffer = serializerBuffers.get();
      serializerBuffers.remove();
    }
    return buffer;
  }
1118096
public static DoubleMinMax[] newArray(int size) {
    DoubleMinMax[] ret = new DoubleMinMax[size];
    for(int i = 0; i < size; i++) {
      ret[i] = new DoubleMinMax();
    }
    return ret;
  }
510045
public static void size(Map<?, ?> parameter, int size, String name) throws IllegalArgumentException {
		if (parameter.size() != size) {
			throw new IllegalArgumentException(String.format("%s size is not %d.", name, size));
		}
	}
1322847
public static Partition unit(int size) {
        Partition unit = new Partition();
        unit.cells.add(new TreeSet<Integer>());
        for (int i = 0; i < size; i++) {
            unit.cells.get(0).add(i);
        }
        return unit;
    }
1291521
@Deprecated
	public static int sizeToInt(final Size size) {
		if (size == null) {
			return -1;
		}
		switch (size) {
			case ZERO:
				return 0;
			case SMALL:
				return MAX_SMALL;
			case MEDIUM:
				return MAX_MED;
			case LARGE:
				return MAX_LARGE;
			default:
				return COMMON_XL;
		}
	}
712936
protected ArrayList<T> createInitializedList(int size) {
		ArrayList<T> list = new ArrayList<T>(size);
		for (int i = 0; i < size; i++)
			list.add(null);
		return list;
	}
591877
public static short[] ensureCapacity(short[] elements, int size) {
        if (size > elements.length) {
            short[] tmp = new short[size*2];
            System.arraycopy(elements, 0, tmp, 0, elements.length);
            elements = tmp;
        }
        return elements;
    }
569461
public EvictionConfigurationBuilder size(long size) {
      attributes.attribute(SIZE).set(size);
      memory().size(size);
      memory().storageType(StorageType.OBJECT);
      return this;
   }
1318364
private static List<String> getSizeRange(String operation, String size)
	{
		return getSizeRange(operation, size, null);
	}
993149
public static String getReadableFileSize(int size) {
        final int BYTES_IN_KILOBYTES = 1024;
        final DecimalFormat dec = new DecimalFormat("###.#");
        final String KILOBYTES = " KB";
        final String MEGABYTES = " MB";
        final String GIGABYTES = " GB";
        float fileSize = 0;
        String suffix = KILOBYTES;

        if (size > BYTES_IN_KILOBYTES) {
            fileSize = size / BYTES_IN_KILOBYTES;
            if (fileSize > BYTES_IN_KILOBYTES) {
                fileSize = fileSize / BYTES_IN_KILOBYTES;
                if (fileSize > BYTES_IN_KILOBYTES) {
                    fileSize = fileSize / BYTES_IN_KILOBYTES;
                    suffix = GIGABYTES;
                } else {
                    suffix = MEGABYTES;
                }
            }
        }
        return String.valueOf(dec.format(fileSize) + suffix);
    }
335474
public static int size(Object list) {
        if (list == null)
            return 0;
        if (list instanceof List)
            return ((List<?>) list).size();
        return 1;
    }
169575
public ByteArray readBytes(int size) throws IOException
   {
      byte[] data = new byte[size];
      m_stream.read(data);
      return new ByteArray(data);
   }
908990
def size(self, size):
        
        clone = self._clone()
        clone._size = size
        return clone