'Float' is not identical to 'UInt8' Swift - swift

Question

I have no idea what's wrong with my code for a Taylor series:
func factorial(n: Int) -> Int {
return n == 0 ? 1 : n * factorial(n - 1)
}
func sin(num: Float) -> Float {
let rad : Float = num * 1.0 / 180.0 * 3.1415926535897;
var sum : Float = rad;
for i in 1...100 {
if (i % 2 == 0) {
sum += Float(pow(rad, 2 * i + 1) / Float(factorial(2 * i + 1)));
} else {
sum -= Float(pow(rad, 2 * i + 1)) / Float(factorial(2 * i + 1));
}
}
return sum;
}
print(sin(123.0));
Here are the errors:
<stdin>:11:17: error: cannot invoke '/' with an argument list of type '(#lvalue Float, $T25)'
sum += Float(pow(rad, 2 * i + 1) / Float(factorial(2 * i + 1)));
~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<stdin>:13:13: error: 'Float' is not identical to 'UInt8'
sum -= Float(pow(rad, 2 * i + 1)) / Float(factorial(2 * i + 1));
^

Answer 1

The pow function needs two arguments of the same type, either Float or Double, and so does the division.
Change your sum +/-=... statements to:
if (i % 2 == 0) {
sum += pow(rad, Float(2 * i + 1)) / Float(factorial(2 * i + 1))
} else {
sum -= pow(rad, Float(2 * i + 1)) / Float(factorial(2 * i + 1))
}

Answer 2

Do you need to deal with both Ints and Floats? Swift is really picky about types, so if you can stick to one, that will make your life way easier. With just Floats, you can get this working by adding a single line:
func factorial(n: Float) -> Float {
return n == 0 ? 1 : n * factorial(n - 1)
}
func sin(num: Float) -> Float {
let rad : Float = num * 1.0 / 180.0 * 3.1415926535897;
var sum : Float = rad;
for i in 1...100 {
let float_index :Float = Float(i)
if (i % 2 == 0) {
sum += Float(pow(rad, 2 * float_index + 1) / Float(factorial(2 * float_index + 1)));
} else {
sum -= Float(pow(rad, 2 * float_index + 1)) / Float(factorial(2 * float_index + 1));
}
}
return sum;
}

Answer 3

I think pow requires its arguments to be of the same type but what you have isn't going to work even if you do sort out that issue. That's because your factorial function is generating numbers that are too big.
The largest 64-bit integral number has about twenty digits while the factorial of 200 has about 375.
Ergo it won't fit into a Int, it won't even fit into a Double (double precision IEEE754 number), which maxes out at about 308 digits (upper range, obviously precision is less).
You'll need to move up to Float80 which provides for several thousand digits of range.
But, again, due to the limited precision, you're likely to introduce a lot of errors into your calculations. This would be true even with the IEEE754 quad precision, limited to about 34 decimal digits of precision.