Thread: Finding kth term of a sequence

I want to write an algorithm to find the kth term of a series given by the following recursive formula:
a_0=1 and a_(k+1)=a_k+1/k!
My code (part of it responsible for calculating the value of a series) does not want to compile:

Code:

float series(int n)
{
float F0 = 1;
float F;
unsigned int i;

if (n == 0)
return(1);

for (i = 1; i <= n; i++) 
{
F = F0 + 1/factorial(i);
F0 = F;
}
return(F);
}

thus my question is why it does not want to work properly and what should i change (for certain factorial function is OK)?

Originally Posted by mmk1234

excuse me, i meant that it actualy compiles and after compilation no matter which number (k) i will type in i recieve an answer equal to 2

You should post a simple, yet complete (i.e. can be compiled), program that exhibits the problem. Then describe what input you're giving, what output you're getting, and what output you're expecting.

OK, this is the code. Input i want to have is a natural number, output i want a value of an kth term of a sequence calculated according to the following formula:

a_0=1 and
a_(k+1)=a_k+(1/k!)

In this program, no matter which number i will type in i always recieve an answer equal to 2. How to fix this?

Code:

#include "stdafx.h"
unsigned long long int factorial(unsigned int n)
{
    if ((n == 0) || (n == 1))
        return(1);
    return(n*factorial(n - 1));

}
float series(int n)
{
  float F0 = 1;
  float F;
  unsigned int i;

  if (n == 0)
    return(1);

  for (i = 1; i <= n; i++) 
  {
    F = F0 + 1/factorial(i);
    F0 = F;
  }
return(F);
}

int _tmain(int argc, _TCHAR* argv[])    
{
    int k;
    printf_s("give number:\n");
    scanf_s("%d", &k);
    printf("series(%d) = %f\n", k, series(k));
    return(0);
}

Since 1 is an integer, and factorial(i) returns a long long int, the result of 1/factorial(i) is a long long int.

You can rely on implicit conversion rules for C arithmetic, and use 1.0f (for floating-point one) or 1.0 (for double-precision one), instead. The compiler will then implicitly convert the divisor to a floating-point type. Personally, I recommend using 1.0f / (float)factorial(i) instead, i.e. do the casts explicitly. I think it is easier for us humans to immediately see which precision/rules are used for the computation that way. Others may disagree.

You should reconsider your types, however. Most current architectures use IEEE-754 binary32 for float, and binary64 for double; the latter would give you a larger range of valid values. In general, double type has at least the same range and precision as float, so for large or precise results, I'd always prefer double.

I'd personally suggest keeping n in factorial() as an integer, but do the calculation and return the result using the double type.