Question: [Gamma function](https://en.wikipedia.org/wiki/Gamma_function) is defined as

[![Gamma function definition](https://i.stack.imgur.com/ES8hs.png)](https://i.stack.imgur.com/ES8hs.png)

It is a well-known fact that for positive integers it coincides with a properly shifted factorial function: `Γ(n) = (n - 1)!`. However, a less famous fact is

> 
> Γ(1/2) = π1/2
> 
> 
> 

Actually, the Gamma function can be evaluated for all half-integer arguments, and the result is a rational number multiplied by π1/2. The formulas, as mentioned in Wikipedia, are:

[![Gamma function for half-integer arguments](https://i.stack.imgur.com/DrL55.png)](https://i.stack.imgur.com/DrL55.png) (for n > 0)

In this challenge, you should write code (program or function) that receives an integer `n` and returns the rational representation of **Γ(1/2 + n) / π1/2**, as a rational-number object, a pair of integers or a visual plain-text representation like `15/8`.

The numerator and denominator don't need to be relatively prime. The code should support values of `n` at least in the range -10 ... 10 (I chose 10 because 20! < 264 and 19!! < 232).

Test cases (taken from Wikipedia):

```
Input | Output (visual) | Output (pair of numbers)
0     | 1               | 1, 1
1     | 1/2             | 1, 2
-1    | -2              | -2, 1
-2    | 4/3             | 4, 3
-3    | -8/15           | -8, 15

```

Answer: 
Pyth - ~~27~~ ~~26~~ ~~25~~ 24 bytes
====================================

Too cumbersome for my liking. Also, implicit input seems not to work with `W`. Uses the ~~second to last~~ first form listed above.

```
_W<QZ,.!yK.aQ*^*4._QK.!K

```

[Test Suite](http://pyth.herokuapp.com/?code=_W%3CQZ%2C.%21yK.aQ%2a%5E%2a4._QK.%21K&test_suite=1&test_suite_input=0%0A1%0A-1%0A-2%0A-3%0A11%0A-11&debug=0).
Haskell, ~~81~~ ~~71~~ 69 bytes
===============================

```
import Data.Ratio
p=product
f n|n<0=1/(p[n+1%2..0-1])|0<1=p[1%2..n-1]

```

This seems bloated, but I'm not sure where to golf this from here. Any golfing suggestions are welcome.

**Edit:** Used the fact that the default step of range `[x..y]` is 1, and moved `product` to `p=product` to save two bytes.

**Ungolfing:**

```
import Data.Ratio
gamma_half n | n < 0     = 1 / ( product [ n + 1%2 .. (-1) ] )
             | otherwise = product [ 1%2 .. n-1 ]

```