'Perform conversions on any other fixed-width column data types.
This may not perform any conversion at all if it\'s not necessary, in
which case the original column array is returned.'

def _convert_other(self, column, field, recformat):

    if isinstance(recformat, _FormatX):
        return self._convert_x(field, recformat)
    (_str, _bool, _number, _scale, _zero, bscale, bzero, dim) = self._get_scale_factors(column)
    indx = self.names.index(column.name)
    if ((not _str) and isinstance(self._coldefs, _AsciiColDefs)):
        field = self._convert_ascii(column, field)
    if dim:
        if (field.ndim > 1):
            actual_shape = field.shape[1:]
            if _str:
                actual_shape = (actual_shape + (field.itemsize,))
        else:
            actual_shape = field.shape[0]
        if (dim == actual_shape):
            dim = None
        else:
            nitems = reduce(operator.mul, dim)
            if _str:
                actual_nitems = field.itemsize
            elif (len(field.shape) == 1):
                actual_nitems = 1
            else:
                actual_nitems = field.shape[1]
            if (nitems > actual_nitems):
                warnings.warn('TDIM{}    value    {:d}    does    not    fit    with    the    size    of    the    array    items    ({:d}).        TDIM{:d}    will    be    ignored.'.format((indx + 1), self._coldefs[indx].dims, actual_nitems, (indx + 1)))
                dim = None
    if ((not column.ascii) and column.format.p_format):
        format_code = column.format.p_format
    else:
        format_code = column.format.format
    if (_number and (_scale or _zero) and (not column._physical_values)):
        if self._uint:
            if ((bzero == (2 ** 15)) and (format_code == 'I')):
                field = np.array(field, dtype=np.uint16)
            elif ((bzero == (2 ** 31)) and (format_code == 'J')):
                field = np.array(field, dtype=np.uint32)
            elif ((bzero == (2 ** 63)) and (format_code == 'K')):
                field = np.array(field, dtype=np.uint64)
                bzero64 = np.uint64((2 ** 63))
            else:
                field = np.array(field, dtype=np.float64)
        else:
            field = np.array(field, dtype=np.float64)
        if _scale:
            np.multiply(field, bscale, field)
        if _zero:
            if (self._uint and (format_code == 'K')):
                test_overflow = field.copy()
                try:
                    test_overflow += bzero64
                except OverflowError:
                    warnings.warn('Overflow    detected    while    applying    TZERO{0:d}.    Returning    unscaled    data.'.format((indx + 1)))
                else:
                    field = test_overflow
            else:
                field += bzero
    elif (_bool and (field.dtype != bool)):
        field = np.equal(field, ord('T'))
    elif _str:
        with suppress(UnicodeDecodeError):
            field = decode_ascii(field)
    if dim:
        nitems = reduce(operator.mul, dim)
        if (field.ndim > 1):
            field = field[:, :nitems]
        if _str:
            fmt = field.dtype.char
            dtype = ('|{}{}'.format(fmt, dim[(-1)]), dim[:(-1)])
            field.dtype = dtype
        else:
            field.shape = ((field.shape[0],) + dim)
    return field
