Concatenates one or more arrays given as arguments.  If given objects and scalars as arguments `cat` will plop them down in place in the result array.  If given an `arguments` object, `cat` will treat it like an array and concatenate it likewise.
771003
function() {
      return _.reduce(arguments, function(acc, elem) {
        if (_.isArguments(elem)) {
          return concat.call(acc, slice.call(elem));
        }
        else {
          return concat.call(acc, elem);
        }
      }, []);
    }
1334440
private double[][] concatenateArrays(double[][] first, double[][] second){
        // I am sure as hell that should be a better way to do this...
        double[][] result = new double[first.length][first[0].length + second[0].length];
        for(int i = 0; i < first.length; i++){
            for (int j = 0; j < (first[i].length + second[i].length); j++){
                if( j < first[i].length){
                    result[i][j] = first[i][j];
                } else{
                    result[i][j] = second[i][j - first[i].length];
                }
            }
        }
        return result;
    }
441798
def concatenate(self, tpl, axis=None):
        
        if axis is None:
            raise NotImplementedError(
                'Sparse tensor concatenation without axis argument is not supported'
            )
        T = self
        for i in range(1, len(tpl)):
            T = _single_concatenate(T, tpl[i], axis=axis)
        return T
1121931
function flatten(array) {
    var result = [], i, n;

    for (i = 0, n = array.length; i < n; i++) {
      if (isArray(array[i])) {
        result = result.concat(flatten(array[i]));
      }
      else {
        result.push(array[i]);
      }
    }

    return result;
  }
1095222
def concatenate_variables(scope, variables, container):
    '''
    
    '''

    # Check if it's possible to concatenate those inputs.
    type_set = set(type(variable.type) for variable in variables)
    number_type_set = {FloatType, FloatTensorType, Int64Type, Int64TensorType}
    if StringType in type_set and any(number_type in type_set for number_type in number_type_set):
        raise RuntimeError('We are not able to concatenate numerical tensor(s) and string tensor(s)')

    input_names = []  # input variables' names we want to concatenate
    input_dims = []  # dimensions of the variables that is going to be concatenated

    # Collect input variable names and do cast if needed
    for variable in variables:
        if isinstance(variable.type, (Int64TensorType, Int64Type)):
            input_names.append(convert_integer_to_float(scope, variable, container))
        else:
            input_names.append(variable.full_name)
        # We assume input variables' shape are [1, C_1], ..., [1, C_n] if there are n inputs.
        input_dims.append(variable.type.shape[1])

    if len(input_names) == 1:
        # No need to concatenate tensors if there is only one input
        return input_names[0]
    else:
        # To combine all inputs, we need a FeatureVectorizer
        op_type = 'FeatureVectorizer'
        attrs = {'name': scope.get_unique_operator_name(op_type), 'inputdimensions': input_dims}
        # Create a variable name to capture feature vectorizer's output
        concatenated_name = scope.get_unique_variable_name('concatenated')
        # Set up our FeatureVectorizer
        container.add_node(op_type, input_names, concatenated_name, op_domain='ai.onnx.ml', **attrs)

        return concatenated_name
575812
function (a, b, c, d, e, ...args) {
	return [a, b, c, d, e].concat(args);
}
117550
def _replace_scalars_in_args(self, args):
        
        _check_type('args', args, list)
        new_args = []
        for arg in args:
            if isinstance(arg, list):
                to_append = self._replace_scalars_in_args(arg)
            elif isinstance(arg, dict):
                to_append = self._replace_scalars_in_kwargs(arg)
            elif isinstance(arg, string_types):
                to_append = self._replace_scalar(arg)
            else:
                to_append = arg
            new_args.append(to_append)
        return new_args
1027407
public static String concatenate(EvaluationContext ctx, Object... args) {
        StringBuilder sb = new StringBuilder();
        for (Object arg : args) {
            sb.append(Conversions.toString(arg, ctx));
        }
        return sb.toString();
    }
585244
def _combine(self, applied, shortcut=False):
        """"""
        applied_example, applied = peek_at(applied)
        coord, dim, positions = self._infer_concat_args(applied_example)
        if shortcut:
            combined = self._concat_shortcut(applied, dim, positions)
        else:
            combined = concat(applied, dim)
            combined = _maybe_reorder(combined, dim, positions)

        if isinstance(combined, type(self._obj)):
            # only restore dimension order for arrays
            combined = self._restore_dim_order(combined)
        if coord is not None:
            if shortcut:
                combined._coords[coord.name] = as_variable(coord)
            else:
                combined.coords[coord.name] = coord
        combined = self._maybe_restore_empty_groups(combined)
        combined = self._maybe_unstack(combined)
        return combined
181053
def concatenate(cls, *args: List['ComponentRef']) -> 'ComponentRef':
        

        a = copy.deepcopy(args[0])
        n = a
        for b in args[1:]:
            while n.child:
                n = n.child[0]
            b = copy.deepcopy(b)  # Not strictly necessary
            n.child = [b]
        return a
604904
function flatten(array) {
        return array.reduce(function (a, b) {
            return isArray(b) ? a.concat(flatten(b)) : a.concat(b);
        }, []);
    }
233698
function() {
      if (arguments.length === 1 && Array.isArray(arguments[0])) {
        list = list.concat(arguments[0]);
      } else {
        list = list.concat([].slice.call(arguments));
      }
    }
808813
def concatenate_1d(arrays):
    
    if len(arrays) == 0:
        return np.array([])
    if len(arrays) == 1:
        return np.asanyarray(arrays[0])
    if any(map(np.ma.is_masked, arrays)):
        return np.ma.concatenate(arrays)
    return np.concatenate(arrays)
642890
function(input, shallow, strict, output) {
    if (shallow && _.every(input, _.isArray)) {
      return concat.apply(output, input);
    }
    for (var i = 0, length = input.length; i < length; i++) {
      var value = input[i];
      if (!_.isArray(value) && !_.isArguments(value)) {
        if (!strict) output.push(value);
      } else if (shallow) {
        push.apply(output, value);
      } else {
        flatten(value, shallow, strict, output);
      }
    }
    return output;
  }
723197
function mergeArrays(objValue, srcValue) {
  if (isArray(objValue) && isArray(srcValue)) {
    return objValue.concat(srcValue)
  }
}
462113
function arraySafeConcat(arr, arg) {
  var result = arrayClone(arr), len = result.length, arr2;
  arr2 = isArray(arg) ? arg : [arg];
  result.length += arr2.length;
  forEach(arr2, function(el, i) {
    result[len + i] = el;
  });
  return result;
}
218640
def _concatenate_shape(input_shape, axis=-1):  # pylint: disable=invalid-name
  """"""
  ax = axis % len(input_shape[0])
  concat_size = sum(shape[ax] for shape in input_shape)
  out_shape = input_shape[0][:ax] + (concat_size,) + input_shape[0][ax+1:]
  return out_shape