<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def add_intersection(s, t, intersections):
 r"""Adds an intersection to list of ``intersections``. .. note:: This is a helper for :func:`from_linearized` and :func:`endpoint_check`. These functions are used (directly or indirectly) by :func:`_all_intersections` exclusively, and that function has a Fortran equivalent. Accounts for repeated intersection points. If the intersection has already been found, does nothing. If ``s`` is below :math:`2^{-10}`, it will be replaced with ``1 - s`` and compared against ``1 - s'`` for all ``s'`` already in ``intersections``. (Similar if ``t`` is below the :attr:`.ZERO_THRESHOLD`.) This is perfectly "appropriate" since evaluating a B |eacute| zier curve requires using both ``s`` and ``1 - s``, so both values are equally relevant. Compares :math:`\|p - q\|` to :math:`\|p\|` where :math:`p = (s, t)` is current candidate intersection (or the "normalized" version, such as :math:`p = (1 - s, t)`) and :math:`q` is one of the already added intersections. If the difference is below :math:`2^{-42}` (i.e. :attr`.NEWTON_ERROR_RATIO`) then the intersection is considered to be duplicate. Args: s (float):
 The first parameter in an intersection. t (float):
 The second parameter in an intersection. intersections (list):
 List of existing intersections. """

    if not intersections:
        intersections.append((s, t))
        return

    if s < _intersection_helpers.ZERO_THRESHOLD:
        candidate_s = 1.0 - s
    else:
        candidate_s = s
    if t < _intersection_helpers.ZERO_THRESHOLD:
        candidate_t = 1.0 - t
    else:
        candidate_t = t
    norm_candidate = np.linalg.norm([candidate_s, candidate_t], ord=2)
    for existing_s, existing_t in intersections:
        # NOTE: |(1 - s1) - (1 - s2)| = |s1 - s2| in exact arithmetic, so
        #       we just compute ``s1 - s2`` rather than using
        #       ``candidate_s`` / ``candidate_t``. Due to round-off, these
        #       differences may be slightly different, but only up to machine
        #       precision.
        delta_s = s - existing_s
        delta_t = t - existing_t
        norm_update = np.linalg.norm([delta_s, delta_t], ord=2)
        if (
            norm_update
            < _intersection_helpers.NEWTON_ERROR_RATIO * norm_candidate
        ):
            return

    intersections.append((s, t))