human
Here's a good function header given the following:
I wrote the below code

    global _ROOT2, _ROOT3, _invROOT3
    if (_ROOT2 is None):
        _roots()
    (a, b) = [Factors(i) for i in (a, b)]
    (ua, ub) = a.normal(b)
    gcd = a.gcd(b).as_expr()
    n1 = n2 = 1
    if (S.NegativeOne in ua.factors):
        ua = ua.quo(S.NegativeOne)
        n1 = (- n1)
    elif (S.NegativeOne in ub.factors):
        ub = ub.quo(S.NegativeOne)
        n2 = (- n2)
    (a, b) = [i.as_expr() for i in (ua, ub)]
    def pow_cos_sin(a, two):
        'Return    ``a``    as    a    tuple    (r,    c,    s)    such    that\n                                ``a    =    (r    or    1)*(c    or    1)*(s    or    1)``.\n\n                                Three    arguments    are    returned    (radical,    c-factor,    s-factor)    as\n                                long    as    the    conditions    set    by    ``two``    are    met.
   otherwise    None    is\n                                returned.    If    ``two``    is    True    there    will    be    one    or    two    non-None\n                                values    in    the    tuple:    c    and    s    or    c    and    r    or    s    and    r    or    s    or    c    with    c\n                                being    a    cosine    function    (if    possible)    else    a    sine,    and    s    being    a    sine\n                                function    (if    possible)    else    oosine.    If    ``two``    is    False    then    there\n                                will    only    be    a    c    or    s    term    in    the    tuple.\n\n                                ``two``    also    require    that    either    two    cos    and/or    sin    be    present    (with\n                                the    condition    that    if    the    functions    are    the    same    the    arguments    are\n                                different    or    vice    versa)    or    that    a    single    cosine    or    a    single    sine\n                                be    present    with    an    optional    radical.\n\n        ...

What's a good function header?
assistant
#Here's a good function header.

def trig_split(a, b, two=False):