human
Can you provide a Python program to compare number exactly given the following:
Complete the below
def assert_index_equal(left, right, exact='equiv', check_names=True, check_less_precise=False, check_exact=True, check_categorical=True, obj='Index'):

    ''''Check that left and right Index are equal.
    Parameters
    left : Index
    right : Index
    exact : bool / string {\'equiv\'}, default False
    Whether to check the Index class, dtype and inferred_type
    are identical. If \'equiv\', then RangeIndex can be substituted for
    Int64Index as well.
    check_names : bool, default True
    Whether to check the names attribute.
    check_less_precise : bool or int, default False
    Specify comparison precision. Only used when check_exact is False.
    5 digits (False) or 3 digits (True) after decimal points are compared.
    If int, then specify the digits to compare
    check_exact : bool, default True
    Whether to compare number exactly.
    check_categorical : bool, default True
    Whether to compare internal Categorical exactly.
    obj : str, default \'Index\'
    Specify object name being compared, internally used to show appropriate
    assertion message'
    '''
assistant
#Here is Python program to compare number exactly.
    def _check_types(l, r, obj='Index'):
        if exact:
            assert_class_equal(left, right, exact=exact, obj=obj)
            assert_attr_equal('dtype', l, r, obj=obj)
            if (l.inferred_type in ('string', 'unicode')):
                assert (r.inferred_type in ('string', 'unicode'))
            else:
                assert_attr_equal('inferred_type', l, r, obj=obj)
    def _get_ilevel_values(index, level):
        unique = index.levels[level]
        labels = index.labels[level]
        filled = take_1d(unique.values, labels, fill_value=unique._na_value)
        values = unique._shallow_copy(filled, name=index.names[level])
        return values
    _check_isinstance(left, right, Index)
    _check_types(left, right, obj=obj)
    if (left.nlevels != right.nlevels):
        raise_assert_detail(obj, '{0}    levels    are    different'.format(obj), '{0},    {1}'.format(left.nlevels, left), '{0},    {1}'.format(right.nlevels, right))
    if (len(left) != len(right)):
        raise_assert_detail(obj, '{0}    length    are    different'.format(obj), '{0},    {1}'.format(len(left), left), '{0},    {1}'.format(len(right), right))
    if (left.nlevels > 1):
        for level in range(left.nlevels):
            llevel = _get_ilevel_values(left, level)
            rlevel = _get_ilevel_values(right, level)
            lobj = 'MultiIndex    level    [{0}]'.format(level)
            assert_index_equal(llevel, rlevel, exact=exact, check_names=check_names, check_less_precise=check_less_precise, check_exact=check_exact, obj=lobj)
            _check_types(left.levels[level], right.levels[level], obj=obj)
    if check_exact:
        if (not left.equals(right)):
            diff = ((np.sum((left.values != right.values).astype(int)) * 100.0) / len(left))
            msg = '{0}    values    are    different    ({1}    %)'.format(obj, np.round(diff, 5))
            raise_assert_detail(obj, msg, left, right)
    else:
        _testing.assert_almost_equal(left.values, right.values,...