Implementation of a double factorial tail-recursive function in C - c

Question

I got stuck trying to implement the following formula in my C code:
N!! = N!/(N-1)!!
The code is supposed to be a tail-recursive function, and although it does work and the computation is correct, I'm pretty sure this is not a tail function + I really can't tell what's going on during the return stage.
My current code:
long long int Factorial(int n)
{
if (n < 0)
return 0;
if (n == 0 || n == 1)
return 1;
return (n*Factorial(n - 1));
}
int DoubleFactorialTail(int n, int fact)
{
if (n < 0)
{
return 0;
}
if (n == 0 || n == 1)
{
return fact;
}
else
{
long long int factorial = Factorial(n);
return (factorial / DoubleFactorialTail(n - 1, fact));
}
}
I know that a double factorial tail-recursive function is supposed to call the recursive function at the end and nothing else, but here what I did was divide it by value(recursive in this case), that's why I'm not so sure my implementation is correct.
EDIT:
I originally tried implementing the following:
long long int DoubleFactorialTail(int n, int fact)
{
if (n < 0)
{
return 1;
}
if (n == 0 || n == 1)
{
return fact;
}
else
{
return (DoubleFactorialTail(n - 2, fact*n));
}
}
and the result will be:
res = (Factorial(n)/DoubleFactorialTail(n-1, 1));
Thing is, we were told that for n<0, the function needs to return 0 and save it in res.
but this equation will have 0 in its denominator if I choose to proceed and implement it this way.
So I guess my main question is: Is there a way to write this code in a tail-recursion manner while keeping this criterion intact?

Answer 1

I know that a double factorial tail-recursive function is supposed to call the recursive function at the end and nothing else
This is true, so
return (n*Factorial(n - 1));
or
return (factorial / DoubleFactorialTail(n - 1, fact));
Is not going to work.
The pattern has to be literally
return CallToRecursive(args);
The reason is that a tail recursive optimization lets CallToRecursive(args); return to the caller of this function and does not add a frame to the call-stack.
If you add code that needs to further process the return value, then it needs a frame in the call-stack to hold the return value and return point, and that's not TCO.
The way to approach this is usually to pass along work in progress to the next call.
long long int FactorialTCO(int n, long long factSoFar)
{
if (n < 0)
return 0;
if (n == 0 || n == 1)
return factSoFar;
return FactorialTCO(n - 1, n * factSoFar);
}
long long int Factorial(int n) {
return FactorialTCO(n, 1);
}
Note that this line:
return FactorialTCO(n - 1, n * factSoFar);
Returns exactly what it gets back from the recursive call. This means the compiler does not need to make a new stack frame, and that call will return to this function's caller. As we do this multiple times, we can effectively jump all the way back to the first caller when we are done instead of unwinding the stack frame.
I leave the transformation of the double up to you or others.