how to exit recursive math formula and still get an answer
Question: i wrote this python code, which from wolfram alpha says that its supposed to
return the factorial of any positive value (i probably messed up somewhere),
integer or not:

    
    
    from math import *
    
    def double_factorial(n):
        if int(n) == n:
            n = int(n)
            if [0,1].__contains__(n):
                return 1
            a = (n&1) + 2
            b = 1
            while a<=n:
                b*=a
                a+= 2
            return float(b)
        else:
            return factorials(n/2) * 2**(n/2) *(pi/2)**(.25 *(-1+cos(n * pi)))
    
    def factorials(n):
        return pi**(.5 * sin(n*pi)**2) * 2**(-n + .25 * (-1 + cos(2*n*pi))) * double_factorial(2*n)
    

the problem is , say i input pi to 6 decimal places. 2*n will not become a
float with 0 as its decimals any time soon, so the equation turns out to be

    
    
    pi**(.5 * sin(n*pi)**2) * 2**(-n + .25 * (-1 + cos(2*n*pi))) * double_factorial(loop(loop(loop(...)))))
    

how would i stop the recursion and still get the answer?

ive had suggestions to add an index to the definitions or something, but the
problem is, if the code stops when it reaches an index, there is still no
answer to put back into the previous "nests" or whatever you call them


Answer: You defined `f` in terms of `g` and `g` in terms of `f`. But you don't just
have a circular definition with no base point to start the recursion. You have
something worse. The definition of `f` is actually the definition of `g`
inverted. `f` is precisely undoing what `g` did and vice versa. If you're
trying to implement gamma yourself (ie. not using the one that's already there
in the libraries) then you need to use a formula that expresses gamma in terms
of something else that you know how to evaluate. Just using one formula and
its inversion like that is a method that will fail for almost any problem you
apply it to.

