'Parameters
input : array or FITS_rec instance
input data, either the group data itself (a
`numpy.ndarray`) or a record array (`FITS_rec`) which will
contain both group parameter info and the data.  The rest
of the arguments are used only for the first case.
bitpix : int
data type as expressed in FITS ``BITPIX`` value (8, 16, 32,
64, -32, or -64)
pardata : sequence of arrays
parameter data, as a list of (numeric) arrays.
parnames : sequence of str
list of parameter names.
bscale : int
``BSCALE`` of the data
bzero : int
``BZERO`` of the data
parbscales : sequence of int
list of bscales for the parameters
parbzeros : sequence of int
list of bzeros for the parameters'

def __new__(cls, input=None, bitpix=None, pardata=None, parnames=[], bscale=None, bzero=None, parbscales=None, parbzeros=None):

    if (not isinstance(input, FITS_rec)):
        if (pardata is None):
            npars = 0
        else:
            npars = len(pardata)
        if (parbscales is None):
            parbscales = ([None] * npars)
        if (parbzeros is None):
            parbzeros = ([None] * npars)
        if (parnames is None):
            parnames = ['PAR{}'.format((idx + 1)) for idx in range(npars)]
        if (len(parnames) != npars):
            raise ValueError('The    number    of    parameter    data    arrays    does    not    match    the    number    of    parameters.')
        unique_parnames = _unique_parnames((parnames + ['DATA']))
        if (bitpix is None):
            bitpix = DTYPE2BITPIX[input.dtype.name]
        fits_fmt = GroupsHDU._bitpix2tform[bitpix]
        format = FITS2NUMPY[fits_fmt]
        data_fmt = '{}{}'.format(str(input.shape[1:]), format)
        formats = ','.join((([format] * npars) + [data_fmt]))
        gcount = input.shape[0]
        cols = [Column(name=unique_parnames[idx], format=fits_fmt, bscale=parbscales[idx], bzero=parbzeros[idx]) for idx in range(npars)]
        cols.append(Column(name=unique_parnames[(-1)], format=fits_fmt, bscale=bscale, bzero=bzero))
        coldefs = ColDefs(cols)
        self = FITS_rec.__new__(cls, np.rec.array(None, formats=formats, names=coldefs.names, shape=gcount))
        self._data_field = unique_parnames[(-1)]
        self._coldefs = coldefs
        self.parnames = parnames
        for (idx, name) in enumerate(unique_parnames[:(-1)]):
            column = coldefs[idx]
            (scale, zero) = self._get_scale_factors(column)[3:5]
            if (scale or zero):
                self._cache_field(name, pardata[idx])
            else:
                np.rec.recarray.field(self, idx)[:] = pardata[idx]
        column = coldefs[self._data_field]
        (scale, zero) = self._get_scale_factors(column)[3:5]
        if (scale or zero):
            self._cache_field(self._data_field, input)
        else:
            np.rec.recarray.field(self, npars)[:] = input
    else:
        self = FITS_rec.__new__(cls, input)
        self.parnames = None
    return self
