There is no need to provide a type signature at all in this case. All your arguments are very simple so you're really not gaining much bug-checking by declaring the type.
How Haskell handles numbers is a bit of a complex topic. What you need to worry about here are the classes Integral and Floating and Num. Int and Integer are instances of Integral and Float and Double are instances of Floating and all four of those types are instances of Num.
The functions you're using are:
(+) :: (Num a) => a -> a -> a
(^) :: (Num a, Integral b) => a -> b -> a
sqrt :: (Floating a) => a -> a
If you break down yout code into subexpressions, you'll get an error message that shows you which one is at fault:
getc :: Integer -> Integer -> Float
getc a b = sum_ab + sqrt_a2_b2
where sum_ab = a + b
sqrt_a2_b2 = sqrt sum_a2_b2
sum_a2_b2 = a2 + b2
a2 = a ^ 2
b2 = b ^ 2
Couldn't match expected type `Float'
against inferred type `Integer'
In the expression: sum_ab + sqrt_a2_b2
(+)'s signature says every argument and its return value must be of the same type, but a+b is an Integer, sqrt returns a some sort of Floating, and your function's signature says the output will be a Float. You need to make all these consistent.
Look up the function fromIntegral to help resolve this.
To answer your question about Int, Integer, Float and Double: Int is a fixed-size integer. If a value gets too large you get integer wrap around:
*Main> let x = 2000000000 :: Int
*Main> x * 2
Integer on the other hand is variable-length. It can grow to hold any size number you want:
*Main> let x = 2000000000 :: Integer
*Main> x * 2
Float and Double are two different sizes of floating point numbers with Double able to store approximately twice as many digits as Float.
*Main> let x = 0.1234567890123456789 :: Double
*Main> let x = 0.1234567890123456789 :: Float
Double can hold every value Float can, and usually can hold any value of Int as well. However Double cannot hold every value of Integer since an integer can grow to by any length, but Double can at most have 16 significant digits (Yes double will go up to values like 10^100, but only the most significant digits of that will be preserved). Also a Double cannot hold an exact value of a repeating decimal such as 1/3. Long, long story short: Integrals, Floating and Rational all have there place.
That's all very incomplete, but I'm already treading into tl;dr territory here so I'll stop here. If you would like some additional details ask and I'll see if I can dredge up a more complete explanation.
For future reference, surround your code with [code]...[/code] tags, This will preserve indentation (which is especially important for Haskell) as well as prevent the forum markup from mangling code. Also include the exact error message you get in your post. This makes it a lot easier to get help.