Array of values with a minimum size that are not objects where each item must match the provided example
@param size minimum size of the array
@param value Value to use to match each item
420612
public PactDslJsonArray minArrayLike(Integer size, PactDslJsonRootValue value) {
    return minArrayLike(size, value, size);
  }
245299
public static PactDslJsonArray arrayEachLike(Integer numberExamples, PactDslJsonRootValue value) {
    PactDslJsonArray parent = new PactDslJsonArray("", "", null, true);
    parent.setNumberExamples(numberExamples);
    parent.matchers.addRule("", parent.matchMin(0));
    parent.putObject(value);
    return parent;
  }
511773
public static PactDslJsonArray arrayMinMaxLike(int minSize, int maxSize, PactDslJsonRootValue value) {
    return arrayMinMaxLike(minSize, maxSize, minSize, value);
  }
842610
public CollectionAssert hasSizeLessThanOrEqualTo(int size) {
		isNotNull();
		int actualSize = size(this.actual);
		if (!(actualSize <= size)) {
			failWithMessage("The size <%s> is not less or equal to <%s>", actualSize,
					size);
		}
		return this;
	}
183424
public Cell<C,T> minSize (float size) {
		minWidth = new FixedValue<C, T>(layout.toolkit, size);
		minHeight = new FixedValue<C, T>(layout.toolkit, size);
		return this;
	}
581754
public void setValue(String value) {
		contents = new ArrayList();
		contents.add(value);
		if (value.trim().length() > 0) {
			containsSingleString = true;
		}
	}
123160
public static void size(Collection<?> parameter, int size, String name) throws IllegalArgumentException {
		if (parameter.size() != size) {
			throw new IllegalArgumentException(String.format("%s size is not %d.", name, size));
		}
	}
1039576
function filledarray(value, size){
  var a = new Array(size);
  for(var i=0; i<size; i++){a[i] = value;}
  return a;
}
1275007
public void add( int val ) 
    {
        if ( size == items.length ) 
            resize( items.length * 2 + 1 );
        items[size++] = val;
    }
781539
public void setInput(float x[], float y[], int size) {
		if (x.length < size || y.length < size) {
			throw new IllegalArgumentException("Arrays too small for size.");
		}
		if (size < M) {
			throw new IllegalArgumentException("Not enough data points for M");
		}

		this.x = x;
		this.y = y;
		this.size = size;
		this.dj = Math.min(1, (int) Math.pow(size, 0.25));
		ascend = x[size - 1] >= x[0];
	}
297159
function(values) {
    var max = Number.MIN_VALUE,
        min = Number.MAX_VALUE,
        val,
        cc,
        attrs = {};

    if (!(this.scale instanceof jvm.OrdinalScale) && !(this.scale instanceof jvm.SimpleScale)) {
      if (!this.params.min || !this.params.max) {
        for (cc in values) {
          val = parseFloat(values[cc]);
          if (val > max) max = values[cc];
          if (val < min) min = val;
        }
        if (!this.params.min) {
          this.scale.setMin(min);
        }
        if (!this.params.max) {
          this.scale.setMax(max);
        }
        this.params.min = min;
        this.params.max = max;
      }
      for (cc in values) {
        val = parseFloat(values[cc]);
        if (!isNaN(val)) {
          attrs[cc] = this.scale.getValue(val);
        } else {
          attrs[cc] = this.elements[cc].element.style.initial[this.params.attribute];
        }
      }
    } else {
      for (cc in values) {
        if (values[cc]) {
          attrs[cc] = this.scale.getValue(values[cc]);
        } else {
          attrs[cc] = this.elements[cc].element.style.initial[this.params.attribute];
        }
      }
    }

    this.setAttributes(attrs);
    jvm.$.extend(this.values, values);
  }
177266
public static List<boolean[]> split(final boolean[] a, final int size) {
        if (size < 1) {
            throw new IllegalArgumentException("The parameter 'size' can not be zero or less than zero");
        }

        if (N.isNullOrEmpty(a)) {
            return new ArrayList<>();
        }

        final int len = a.length;
        final List<boolean[]> res = new ArrayList<>(len % size == 0 ? len / size : (len / size) + 1);

        for (int from = 0, toIndex = a.length; from < toIndex; from += size) {
            res.add(copyOfRange(a, from, from <= toIndex - size ? from + size : toIndex));
        }

        return res;
    }
1185414
public static void fillArray(Object[] array, Object value) {

        int to = array.length;

        while (--to >= 0) {
            array[to] = value;
        }
    }
316836
private void matchItemIds(@NonNull ArrayMap<View, TransitionValues> unmatchedStart,
                              @NonNull ArrayMap<View, TransitionValues> unmatchedEnd,
                              @NonNull LongSparseArray<View> startItemIds,
                              @NonNull LongSparseArray<View> endItemIds) {
        int numStartIds = startItemIds.size();
        for (int i = 0; i < numStartIds; i++) {
            View startView = startItemIds.valueAt(i);
            if (startView != null && isValidTarget(startView)) {
                View endView = endItemIds.get(startItemIds.keyAt(i));
                if (endView != null && isValidTarget(endView)) {
                    TransitionValues startValues = unmatchedStart.get(startView);
                    TransitionValues endValues = unmatchedEnd.get(endView);
                    if (startValues != null && endValues != null) {
                        mStartValuesList.add(startValues);
                        mEndValuesList.add(endValues);
                        unmatchedStart.remove(startView);
                        unmatchedEnd.remove(endView);
                    }
                }
            }
        }
    }
660411
private void grow(int size) {
		if (this.value.length < size) {
			char[] value = new char[ Math.max(this.value.length * 3 / 2, size)];
			System.arraycopy(this.value, 0, value, 0, this.len);
			this.value = value;
		}
	}
461821
public Cell<C,T> maxSize (Value<C,T> size) {
		maxWidth = size;
		maxHeight = size;
		return this;
	}
376716
public void setValue(int size, float[] newValue) {
        if ( ((newValue.length%2) == 0) && ((newValue.length/2) == size)) {
            try {
                for (int i = 0; i < size; i++) {
                    value.set(i, new SFVec2f(newValue[i*3], newValue[i*3+1]));
                }
            }
            catch (IndexOutOfBoundsException e) {
                Log.e(TAG, "X3D MFVec2f setValue(size,newValue[]) out of bounds." + e);
            }
            catch (Exception e) {
                Log.e(TAG, "X3D MFVec2f setValue(size, newValue[]) exception " + e);
            }
        }
        else {
            Log.e(TAG, "X3D MFVec2f setValue() set with newValue[] length not multiple of 2, or equal to size parameter");
        }
    }