Capitalize first letter.

    Parameters
    ----------
    array : numpy.ndarray or WeldObject
        Input data.

    Returns
    -------
    WeldObject
        Representation of this computation.
493629
def weld_str_capitalize(array):
    
    obj_id, weld_obj = create_weld_object(array)

    weld_template = """map(
    {array},
    |e: vec[i8]|
        let lenString = len(e);
        if(lenString > 0L,
            let res = appender[i8];
            let firstChar = lookup(e, 0L);
            let res = if(firstChar > 96c && firstChar < 123c, merge(res, firstChar - 32c), merge(res, firstChar));
            result(
                for(slice(e, 1L, lenString - 1L),
                    res,
                    |c: appender[i8], j: i64, f: i8|
                        if(f > 64c && f < 91c,
                            merge(c, f + 32c),
                            merge(c, f)
                        )
                )
            ),
            e)
)"""

    weld_obj.weld_code = weld_template.format(array=obj_id)

    return weld_obj
1248282
def extract_first(name)
      return unless name && name.size >= 1

      @first = name.first
      name.delete_at(0)

      @first.capitalize! unless @first =~ /[a-z]/ && @first =~ /[A-Z]/
    end
1360846
public static String capitalize(String name) {
		if (name == null || name.length() == 0) {
			return name;
		}
		return name.substring(0, 1).toUpperCase(ENGLISH) + name.substring(1);
	}
829263
@Transformer
    public static String capFirst(Object o) {
        if (null == o) return "";
        String string = o.toString();
        if (string.length() == 0) {
            return string;
        }
        return ("" + string.charAt(0)).toUpperCase() + string.substring(1);
    }
425572
def analysis_title_header_element(feature, parent):
    """"""
    _ = feature, parent  # NOQA
    header = analysis_title_header['string_format']
    return header.capitalize()
1360809
public static String camelize(final String text, final boolean capitalizeFirstChar)
    {
        StringBuilder sb = new StringBuilder();
        String[] tokens = text.split("[\\.\\s_-]+");

        if (tokens.length < 2)
            return capitalizeFirstChar ? capitalize(text) : text;

        for (String token : tokens)
            sb.append(capitalize(token));

        return capitalizeFirstChar ? sb.toString() : sb.substring(0, 1).toLowerCase(currentLocale())
                + sb.substring(1);
    }
1367489
public static String capitalize( String text )
    {
        if (text == null || text.length() == 0)
            return text;
        
        if (Character.isLowerCase(text.charAt(0)))
            return Character.toUpperCase(text.charAt(0)) + text.substring(1);
        else
            return text;
    }
317965
function ( obj ) {
		var s = string.trim( obj ).replace( /\.|_|-|\@|\[|\]|\(|\)|\#|\$|\%|\^|\&|\*|\s+/g, " " ).toLowerCase().split( regex.space_hyphen ),
		    r = [];

		array.each( s, function ( i, idx ) {
			r.push( idx === 0 ? i : string.capitalize( i ) );
		});

		return r.join( "" );
	}
710357
def corrArray(self, inputArray):
        
        outputArray = numpy.vstack([numpy.nan_to_num(currSpline(inputArray))
                                    for currSpline in self.splines
                                    ]).mean(axis=0)
        return outputArray
625119
public static <E> E first(E[] array) {
        return new FirstElement<E>().apply(new ArrayIterator<>(array));
    }
1188159
function capitalize(value) {
  var result = []
  var index = -1
  var length = value.length

  while (++index < length) {
    result[index] = value[index].charAt(0).toUpperCase() + value[index].slice(1)
  }

  return result
}
589684
function camelCase (str, capitaliseLead = false) {
  str = str.replace(/_([a-z])/g, (group) => {
    if (group[1]) {
      return group[1].toUpperCase()
    }
  })
  if (capitaliseLead) {
    return str.charAt(0).toUpperCase() + str.slice(1)
  } else {
    return str
  }
}
1301940
def p_array_literal_1(self, p):
        """"""
        p[0] = self.asttypes.Array(items=p[2])
        p[0].setpos(p)
922777
def weld_str_startswith(array, pat):
    
    obj_id, weld_obj = create_weld_object(array)
    pat_id = get_weld_obj_id(weld_obj, pat)

    """alternative implementation for reference
    let res = result(
        for(zip(slice(e, 0L, lenPat), {pat}),
            merger[i64, +],
            |b: merger[i64, +], i: i64, e: {{i8, i8}}|
                if(e.$0 == e.$1, 
                    merge(b, 1L), 
                    merge(b, 0L)
                )
        )
    );
    res == lenPat
    """

    weld_template = """let lenPat = len({pat});
map({array},
    |e: vec[i8]|
        let lenString = len(e);
        if(lenPat > lenString,
            false,
            iterate({{0L, true}}, 
                |q| 
                    let found = lookup(e, q.$0) == lookup({pat}, q.$0);
                    {{
                        {{q.$0 + 1L, found}}, 
                        q.$0 + 1L < lenPat &&
                        found == true
                    }}
            ).$1
        )
)"""

    weld_obj.weld_code = weld_template.format(array=obj_id,
                                              pat=pat_id)

    return weld_obj
469038
def each_capitalized
      block_given? or return enum_for(__method__)
      @header.each do |k,v|
        yield capitalize(k), v.join(', ')
      end
    end
859495
def first(self, skipna=None, keep_attrs=None):
        
        return self._first_or_last(duck_array_ops.first, skipna, keep_attrs)
257653
def from_array(array):
        
        if array is None or not array:
            return None
        # end if
        assert_type_or_raise(array, dict, parameter_name="array")
        from pytgbot.api_types.sendable.reply_markup import InlineKeyboardButton
        

        data = {}
        data['inline_keyboard'] = InlineKeyboardButton.from_array_list(array.get('inline_keyboard'), list_level=2)
        
        instance = InlineKeyboardMarkup(**data)
        instance._raw = array
        return instance