Return an Array with the data splitted by a separator.
   a=Daru::Vector.new(["a,b","c,d","a,b","d"])
   a.splitted
     =>
   [["a","b"],["c","d"],["a","b"],["d"]]
772633
def splitted sep=','
      @data.map do |s|
        if s.nil?
          nil
        elsif s.respond_to? :split
          s.split sep
        else
          [s]
        end
      end
    end
383898
private List<byte[]> splitBytes(byte[] array, byte delimiter) {
		List<byte[]> byteArrays = new ArrayList<byte[]>();
		int begin = 0;

		for (int i = 0; i < array.length; i++) {
			// first find delimiter.
			while (i < array.length && array[i] != delimiter) {
				i++;
			}
			byteArrays.add(Arrays.copyOfRange(array, begin, i));
			begin = i + 1;
		}
		return byteArrays;
	}
1025057
def parse(v):
        

        parts = v.split(',')

        slices = []

        for part in parts:
            p = part.split(':')

            if len(p) == 1:
                slices.append(int(p[0]))
            elif len(p) == 2:
                slices.append(tuple(p))
            else:
                raise ValueError("Too many ':': {}".format(part))

        return slices
665534
public static String[] split(String strings, String separator) {
		return split(strings, separator, DEFAULT_TRIM);
	}
902778
def *(par1)
      out = Vector.new(self)
      if par1.is_a?Numeric
        out.x *= par1
        out.y *= par1
        if out.z != nil
          out.z *= par1
        end
      elsif par1.is_a?Matrix
        return (self.to_matrix * par1).to_vector
      elsif par1.is_a?Vector
        ary1 = [self.x, self.y]
        if out.z != nil
          ary1 << out.z
        end

        ary2 = [par1.x, par1.y]
        if out.z != nil
          ary2 << par1.z
        end

        aryr = Matrix.mult_array(ary1, ary2)
        out.x = aryr[0]
        out.y = aryr[1]
        if aryr[2] != nil
          out.z = aryr[2]
        end
      else
        Error.call "Unable to add '#{par1} to this vector", Error::ERR_HIGH
      end
      return out
    end
652330
public static List<String> split(String str, char separator, int limit, boolean isTrim, boolean ignoreEmpty){
		return split(str, separator, limit, isTrim, ignoreEmpty, false);
	}
496043
def splitlines(self, keepends=False):
        
        # Py2 str.splitlines() takes keepends as an optional parameter,
        # not as a keyword argument as in Python 3 bytes.
        parts = super(newbytes, self).splitlines(keepends)
        return [newbytes(part) for part in parts]
450083
function split(arr, size) {
  var out = [];
  var sizes = [];
  var where = size - 1;
  var ptr = 0;
  var i, j;

  for (i = arr.length - 1; i >= 0; i--) {
    sizes[where] = (sizes[where] || 0) + 1;
    if (--where === -1) where = size - 1;
  }

  for (i = 0; i < size; i++) {
    for (j = 0; j < sizes[i]; j++) {
      if (j === 0) out[i] = [arr[ptr]];
      else out[i].push(arr[ptr]);
      ptr++;
    }
  }

  return out;
}
814662
def _splitit(self, line, isheader):
        

        line_wrapped = []
        for cell, width in zip(line, self._width):
            array = []
            for c in cell.split('\n'):
                array.extend(textwrap.wrap(unicode(c, 'utf'), width))
            line_wrapped.append(array)
        max_cell_lines = reduce(max, map(len, line_wrapped))
        for cell, valign in zip(line_wrapped, self._valign):
            if isheader:
                valign = "t"
            if valign == "m":
                missing = max_cell_lines - len(cell)
                cell[:0] = [""] * (missing / 2)
                cell.extend([""] * (missing / 2 + missing % 2))
            elif valign == "b":
                cell[:0] = [""] * (max_cell_lines - len(cell))
            else:
                cell.extend([""] * (max_cell_lines - len(cell)))
        return line_wrapped
1321270
function splitRow(s, delimiter) {
    var row = [], c, col = '', i, inString = false;
    s = s.trim();
    for (i = 0; i < s.length; i += 1) {
        c = s[i];
        if (c === '"') {
            if (s[i+1] === '"') {
                col += '"';
                i += 1;
            } else {
                inString = !inString;
            }
        } else if (c === delimiter) {
            if (!inString) {
                row.push(col);
                col = '';
            } else {
                col += c;
            }
        } else {
            col += c;
        }
    }
    row.push(col);
    return row;
}
915283
public static String[] split(String target, char[] separatorChars) {
    if (null == target) { return new String[0]; }
    char[] sb = target.toCharArray();
    for (char separator : separatorChars) {
      if (separator != ',') {
        for (int i = 0; i < sb.length; i++)
          if (sb[i] == separator) sb[i] = ',';
      }
    }
    String[] targets = split(new String(sb), ',');
    List<String> list = CollectUtils.newArrayList();
    for (String one : targets) {
      if (isNotBlank(one)) list.add(one.trim());
    }
    String[] rs = new String[list.size()];
    list.toArray(rs);
    return rs;
  }
762273
def split(string, callback=None, sep=None):
    
    if callback is not None:
        return [callback(i) for i in string.split(sep)]
    else:
        return string.split(sep)
257066
def transpose
      Daru::DataFrame.new(
        each_vector.map(&:to_a).transpose,
        index: @vectors,
        order: @index,
        dtype: @dtype,
        name: @name
      )
    end
1040474
def split_data(data, subset, splits):
  '''
  '''

  return dict([(k, data[k][splits[subset]]) for k in data])
1127419
function subArrayJoin(a, separator, from, to) {
    return a.slice(from, to + 1).join(separator);
}
1168962
def split(self, sep=None, maxsplit=sys.maxsize):
    
    return WordList(self._strkey().split(sep, maxsplit), parent=self)
929204
def split(self, bits_count):
		
		result = []
		array = WBinArray(self.__value, self.__size)

		if (len(array) % bits_count) > 0:
			array.resize(len(array) + (bits_count - (len(array) % bits_count)))

		while len(array):
			result.append(WBinArray(array[:bits_count], bits_count))
			array = array[bits_count:]
		return result