Math Is Fun Forum

i wrote this python code, which from wolfram 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                          # checks if its even or odd and starts the a value at 2 or 3
		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)))                  # go to the next definition

def factorials(n):
	return pi**(.5 * sin(n*pi)**2) * 2**(-n + .25 * (-1 + cos(2*n*pi))) * double_factorial(2*n)                  # go back up

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

I'm writing a hashing algorithm that generates arbitrarily long hashes. the problem is, if i use one long string/list of data, the computer will run out of ram. one of the only efficient way to generate the hash is the Merkle-Damgård construction (the other methods might become copyrighted, so i'd rather not use them). however, that involves breaking data up into many pieces, called blocks, and then running each block through the actual algorithm. the question is, how big should the blocks be? I want them to be at least B (output length in nibbles) * 4 bits long, but not too large. however, the last block of data could be much smaller than the number generated by the function (that i want to find), causing errors

basically:
too big blocks→ too much time running through each block, RAM runs out
too small blocks→ the end result will be too small, too much time is wasted running through the numerous blocks, wrong output size

given A = (any value ≥0) input size in bytes, B = (any value >0) output size in nibbles (4 bits), is there a good function f(A) or f(A,B) that will tell me how large a block should be?

program page: http://calccrypto.wikidot.com/hash-2x-v2