Approximating PI using the Taylor Series - Help!

Hey. I want to write a program that approximates the value of PI using the Taylor Series. This is the program I've written so far but I'm not sure how to complete the FOR loop. Someone please help.

Code:

---

#include <cstdlib>
#include <iostream>


using namespace std;


int main(int argc, char *argv[])
{
    cout<<"Piapproximation\n"
    "Welcome to my version of Piapproximation\n";
    //declaring variables
    int terms;
    double pi = 0.0;
    //getting input from user
    cout<<"\nEnter the number of terms: ";
    cin>> terms;
    //loop to calculate the value of pi
    for (long int i = 1; i <= terms; i ++)
    ...
    //output
    cout<<"\nThe approximation of PI is: "<< pi <<
    "\n\nThank you!\n";
   
    system("PAUSE");
    return EXIT_SUCCESS;
}

---

Use a flowchart to complete your logic, then translate to code.

I remember a π approximation we had done.We had used a do while loop,because the concept was to stop while the term was too small for us to be taken into account.We calculated the π which comes from the greek(of course) word περιφέρεια (=regional) by this series

Code:

---

π²/6 = 1/1² + 1/2² + 1/3² + 1/4² + 1/5² + 1/6² + 1/7² + 1/8² + ...

---

The tolerance is achieved by this

Code:

---

while (currentTerm > 1.0e-15);  /* Stop if current term is very small */

---

You can change the tolerance for more or less precision :)

Try writing your program and post back if needed :)

Dude, do not hand out solutions!

Quote:

---

Originally Posted by Elysia

Dude, do not hand out solutions!

---

Edited post.Sorry Elysia,this is the second time i make the same mistake! :/

Quote:

---

We calculated the π which comes from the greek(of course) word περιφέρεια (=regional) by this series

---

Given the definition of pi I find that odd. It has nothing to do with circumference and wikipedia says you're wrong. Are you really right?

Quote:

---

Originally Posted by whiteflags

Given the definition of pi I find that odd. It has nothing to do with circumference and wikipedia says you're wrong. Are you really right?

---

Well i wasn't there when great greek mathematicians lived,so i will tell you what i was told ;) .It is said that because if you select a random cycle and you calculate the fraction of its regional (=περιφέρεια) to its diameter (=διάμετρος) then you always get the number π.As a result π is said to be derived by the word περιφέρεια. It is also said that Epimarchos (=Επίμαρχος) invented the letter π in greek alphabet,but this is mythology.
So my answer is i do not know 100%,but this is a very interesting question.I will search it and i will post it to the general discussions thread if i have something.For now let's stick to the NewP's code and do not get much off topic :)

EDIt- another idea is that π could be derived by the greek word περίμετρος (=perimeter)

Quote:

---

Originally Posted by std10093

Edited post.Sorry Elysia,this is the second time i make the same mistake! :/

---

Well, if you did it by mistake, then we're fine :)
We all make mistakes :(

Please have a go at writing the loop body and then post your attempt.

the taylor series is a really lousy approximation for pi though.

given the formula π²/6 = 1/1² + 1/2² + 1/3² + 1/4² + 1/5² + 1/6² + 1/7² + 1/8² + ... + 1/n²

n must be a VERY large number to get useful results.

Quote:

---

Originally Posted by Elkvis

the taylor series is a really lousy approximation for pi though.

given the formula π²/6 = 1/1² + 1/2² + 1/3² + 1/4² + 1/5² + 1/6² + 1/7² + 1/8² + ... + 1/n²

n must be a VERY large number to get useful results.

---

That's not wrong.With the precision i stated before

Code:

---

while (currentTerm > 1.0e-15);

---

i got this result.

output

Code:

---

Summed 31622777 terms, pi is 3.14159

---

However this a school project,rather than a scientific application so i thought it would be ok ;)

I wrote a multithreaded version that does it 40 billion times, and got 3.141592645... - should be 3.141592653...

given a sufficiently fast computer, you could calculate it within the precision of a double in a reasonable amount of time.

I calculated the absolute error of that(where x' is the machine number)
x' = 3.141592645

x= 3.141592653 (actual value)

Code:

---

|ε| = |x - x'| = 0.000000008 = 0.08 * 10^(-7) < 0.5*10^(-7)

---

which tell us that the machine value is going to be accurate at 7 decimal digits at the most.Here it is exact 7 digits.

Then i calculated the absolute relative error

Code:

---

|ρ| = |ε| / x = 0,025464790899483937645941521750815 * 10^(-7) = 0,025464790899483937645941521750815 * 10^(-9) < 5 * 10^(-9)

---

which says that at the most nine significant digits are going to be accurate.Here 8 digits are accurate.

However i think that this accuracy is satisfactory for a school exercise,so the series i gave before i think is enough :)

either I'm missing something, or you're leaving out a lot of information about the formulas you used to calculate that absolute relative error.

It says right there,

Code:

---

|ρ| = |ε| / x = |x - x'| / x

---

yes, I can clearly see that, but there is no explanation of how that formula does what std10093 says it does. are you calculating the absolute relative error of this instance only, or of floating point operations in general? all I see is a couple of strings of mathematical operations, with no reference to why they're appropriate in this case, or where they came from. I can't even google it without a little more context.

Oh, they're pretty standard for numerical calculations, and they make sense, too.
They are used in general to see how well your approximation compares to the real number. Obviously very important when approximating numbers to see that you actually don't get a half-baked approximation.
Approximation error - Wikipedia, the free encyclopedia

Elkvis these formulas come from the lesson numerical analysis of the theoretical informatics we study at DIT.As Elysia stated and you can see in the link,these formulas are in general and give the information i provided for an instance,not in general.The errors i posted were refering to the value you calculated by doing it 40 million times and for the actual value of π.However i would be very glad to see how the code that calculated this looks like.If you have problem posting it,you could send me a pm,please :D

pm sent

edit: and it was actually 40 billion times :)

Thank you very much.I appreciate it.Yes you are right about the billion :D

Quote:

---

the taylor series is a really lousy approximation for pi though.

---

That specific instance is really bad.

Other forms of the "Taylor Series" work much better.

Soma

Quote:

---

Originally Posted by phantomotap

That specific instance is really bad.

Other forms of the "Taylor Series" work much better.

Soma

---

Could you suggest one just to compare the results? :)

The one that I am familiar with is Pi/4 = 1 - 1/3 + 1/5 - 1/7 + ... with the denominators staying odd.

I tried what whiteflags said and got the following results :

with criterion to stop

Code:

---

while (current > 1.0e-10);

---

i had to calculate 1073741825 and π=3.14159
With the one i suggest before i calculated 100000 and got p=3,14158 (should be 3.14159..)

Then i changed the criterion to stop to

Code:

---

while (current > 1.0e-15);

---

and got the same results with whiteflags's formula as with the previous criterion(that was not expected)
and with the one i had suggested the result is

Code:

---

Summed 31622777 terms, pi is 3.14159

---

Of course i have no problem posting the code,but this post ,supposedly,is for a homework of someone(who has lost interest too soon how ever),so i would ask what are the results for you?

Not really sure what you're doing.

Code:

---

#include <iostream>
#include <sstream>
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cout << "Compute pi with the expansion of arctan 1\n";
        std::cout << "usage: exe [terms]\n";
        return 0;
    }

    std::stringstream args(argv[1]);
    int terms;
    args >> terms;
    bool toggle = false;
    double taylor = 1.0;
    for (int i = 3; i < terms; i+=2)
    {
        if (toggle)
            taylor += 1./i;
        else
            taylor -= 1./i;

        toggle = !toggle;
    }
    double pi = 4 * taylor;
    std::cout << pi << "\n";
}
// my output:
// 3.14139

---

With this I get 4 digits of precision after 10000 terms.

You get four digits precision you said with 100000,but you did not state if these are significant or decimal.I think you mean significant,if your output is that in line 30(with 10000 terms).
So i think that is clear that with your formula we have to calculate more terms to achieve the same precision as in 'my' formula.However your formula does less operations.But if we consider that the formula i posted has to calculate far less terms,i think that mine is better. :)

EDIT - > you may give me a cookie again :D

Quote:

---

Could you suggest one just to compare the results?

---

I'm sorry. I actually can't.

What I know of this stuff comes from research about fast approximations, but it has been years since I read the paper.

I don't remember the exact numbers or anything, but I noticed it because it was orders of magnitude difference in calculations which obviously struck me as being very significant.

[Edit]
I'm sure they are only a search away in any event.

Probably something along the lines of "a faster Taylor series for pi".
[/Edit]

Soma

Quote:

---

Originally Posted by phantomotap

I'm sorry. I actually can't.

What I know of this stuff comes from research about fast approximations, but it has been years since I read the paper.

I don't remember the exact numbers or anything, but I noticed it because it was orders of magnitude difference in calculations which obviously struck me as being very significant.

Soma

---

Oh,that's ok :) Whiteflags suggested a formula by the way

Quote:

---

Originally Posted by std10093

EDIT - > you may give me a cookie again :D

---

I don't trust your research this time. You did not show your implementation and I don't know the significance of what I saw. After 1 million terms I definitely get something that looks like a lot like pi. You might want to experiment more to find the differences for yourself.

I don't care - would just do 4 * arctan(1.0) anyway.

Nobody ask for it.So no cookie this time.As for the arctan it is true. :)

Quote:

---

I don't care - would just do 4 * arctan(1.0) anyway.

---

I'd just use a constant.

Soma

Quote:

---

Originally Posted by phantomotap

I'd just use a constant.
Soma

---

Solution found :D

Quote:

---

Originally Posted by phantomotap

I'd just use a constant.

Soma

---

I like M_PI from math.h.
But, so far I have never needed it and had the compiler I was using supply it at the same time.

Tim S.

I might do the loop more like this:

Code:

---

double numerator = -1.0
double taylor = 1.0;
for (int i = 3; i < terms; i+=2, numerator *= -1)
{
    taylor += numerator/i;
}

---

but to each his own.