Thread: Splitting result into different varibles for Maclaurin expansion

I have another problem which I cant seem to figure out,

I was wondering how it would be possible to calculate a Euler's number using maclaurin's series up to 30~35 digits, until the 30th power.

f(x)=f(0)+f'(0)+f''(0)*x^2/2!+f'''(0)*x^3/3!+f''''(0)*x^4/4!+...+f^n(0)*x^n/n!

Is the basic formula, but as the integers in c++ have a certain digit limit It cannot show until up to 30~35 digits.
That is kinda hard to understand but as i cannot post urls now youd have to google a better one



I was thinking to split up the value storing the digits by 5 each using series [x] but I cannot figure out how the hell to split up something inside there. As for the calculation of the formula, its not hard as a outer function lets me calculate the factorials.

as an example,
for the power being 1,
i would need a variable x to store the number of that certain power in the expansion. Since the power is 1,
x=f'(0)=1.0000000000~
and a variable e which stores the total number calculated thus far.

As a general form it should go like this.
pow=1, x=1.000000000~ e=2.0000000000~
pow=2, x=0.500000000~ e=2.5000000000~
pow=3, x=1.666666666~ e=2.6666666666~

So yeah, I know how to use the split storage in order to make the operation between 2 16 digit numbers split into 8 each but in that case, you input the values by yourself, while in this the program should run by itself storing the result of the division.

Any help would be appreciated.

I'm not sure I know what the difference is you're thinking of. If you know how to split up a 32-bit integer into two 16-bit integer, it doesn't matter where the number comes from? You will have to write routines to operate on these pairs-of-numbers (i.e. you'll have to do carry and things yourself).

Thanks for the answer,

Basically I need to split the already calculated result into different variables.

The fact that I used INT is because of the following.

Lets say that I have declared int x[6]
And that the result for euler's number expansion of the third exponent is 0.166666666666666666666666666666

And I want to split it so

x[0]=0
x[1]=16666
x[2]=66666
and so on
So I dont really need the use of double because I wont be having anything requiring doubles
Then I want to add this number to the total of the expanded Euler's number until now.

The results for the first and second exponential were :
1.000000000000000000000
0.500000000000000000000
those will be added to the total of Euler's number which is I have declared as int e[6].

In the case of expanding until the third power we get
e=2.6666666666666666666666
Which is basically by adding all what we get from the formula.
This too will be split into numbered variables like x was
What I am thinking is that there could be added some variation to the division in the formula to gain the exact number I need for each part, but i still don't get it

Adding up the sum is something i have done and Is possible, but what I really want is how to get the specific value stored in the specific variable slot

So you don't want bignum, or even splitting(!), but rather just fixed point. I forget right now whether GMP has such (or equivalent high-precision float). Note also that division isn't going to get you from 0.16666 to 16666....

This was supposed to be achievable by only having knowledge about series, but I dont understand how the hell to split these

So I guess the question is: why are you using int? Why aren't you using long double? Are you actually supposed to have 30 decimal digits of accuracy, or will you settle for 18 (which is what long double guarantees on my machine)?

For ease of understanding, you could do an array of characters. Each character holds a single digit 0 though 9. Do math on the arrays like you would by hand - add/subtract just requires you to carry or borrow digits between each element :

Code:

int carry = 0;
for (int i = 0; i < ARRAY_LEN; i++)
{
     int sum = op1[i] + op2[i] + carry;
     result[i] = sum % 10;
     carry = sum / 10;
}
if (carry)
   printf ("Overflow!");

Subtraction is similar. Assuming you're not limited on time, multiplication is just repeated addition. Division is repeated subtraction with some hacks to get the remainder into a fractional form. Search for "arbitrary precision multiplication" and "arbitrary precision division" for quicker ways to do either.

Using your idea of putting 5 decimal digits per int is similar - instead of 10 in my code you'll want to mod & divide by 10000. And doing this in fixed point will make things even more complex - you'll have to make a decision up front how many digits you need on either side of the decimal place. Sounds easy since you know the result is 2.x, but some of the intermediate math may produce results with a much larger integer portion.

Are you sure you're understanding the question correctly? Normally these types of questions are to make you understand that even though x^N and N! individually will overflow, you can reuse part of the previous step to calculate it so that it doesn't. You just start with X, then each time through the loop multiply by x and divide by N instead of calculating x^N and N! each iteration. This won't give you 30 digits of precision but should give you close to the limits of precision of whatever floating point value you're using to hold the final result.

This is supposed to make you use series like x[n] in order to divide a result into multiple parts and use functions to calculate the results and such.

According to it,
I need to find the specific part of the Maclaurin's Expansion and calculate it.

So the X in e=1+x+(1/2!)*x and so on is always 1
Giving us e=1+1+1/2!+1/3!+1/n! to calculate

The program should calculate it in order of the N

so If N is 1 it will calculate only the corresponding factorial division part;
meaning that one part of the variable will hold the result of the calculation which will be x=1.00000000~ and the other will hold the actual sum up until now which is e=2.000000~

For N=2
x=1/2!, e=previous e+x

for N=3
x=1/3!, e=previous e+x

each time the result is calculated, it needs to hold all the numbers after the dot into separate variables like x[1] x[2] x[3] until all the 30~35 digits are filled with them.
so when printing out, in the case of N=2

x[0].x[1]x[2]x[3]~
should come out as
0.50000000000000000000
where x[0] should hold the value above the dot and x[1~3] would be holding the rest in 5 digits each.

Well yeah Sorry if my explanation sucks but This is what its asking.
And I cant use bigint as it defeats the purpouse

Originally Posted by Brother_Sharp

This is supposed to make you use series like x[n] in order to divide a result into multiple parts and use functions to calculate the results and such.

According to it,
I need to find the specific part of the Maclaurin's Expansion and calculate it.

So the X in e=1+x+(1/2!)*x and so on is always 1
Giving us e=1+1+1/2!+1/3!+1/n! to calculate

The program should calculate it in order of the N

so If N is 1 it will calculate only the corresponding factorial division part;
meaning that one part of the variable will hold the result of the calculation which will be x=1.00000000~ and the other will hold the actual sum up until now which is e=2.000000~

For N=2
x=1/2!, e=previous e+x

for N=3
x=1/3!, e=previous e+x

each time the result is calculated, it needs to hold all the numbers after the dot into separate variables like x[1] x[2] x[3] until all the 30~35 digits are filled with them.
so when printing out, in the case of N=2

x[0].x[1]x[2]x[3]~
should come out as
0.50000000000000000000
where x[0] should hold the value above the dot and x[1~3] would be holding the rest in 5 digits each.

Well yeah Sorry if my explanation sucks but This is what its asking.
And I cant use bigint as it defeats the purpouse

I'm with tabstop that you're misunderstanding what's being asked. Can you copy and paste the exact text of the question?

This part :

meaning that one part of the variable will hold the result of the calculation which will be x=1.00000000~ and the other will hold the actual sum up until now which is e=2.000000~

Makes me think you have two variables. One's the sum so far. The other is X = 1/n! for the previous value of n. To get the next sum, do

Code:

X /= n;
sum += other;
n += 1

That is, each x[N] isn't a discrete set of digits that gets mushed together to form the final output, it's then next value you add to sum. Each x[N] has digits which contribute to change many of the digits instead of your idea that x[1] is digits 1-5 after the decimal point and the other x[] values have nothing at all to do with them.

x[0] = 1 = 1.00000
x[1] = 1 = 1.00000
x[2] = 1/2 = 0.50000
x[3] = 1/6 = 0.16667
x[4] = 1/24 = 0.04167

Note how both x[0] and x[1] change the integer part of the sum, and x[2] and x[3] both contribute to the digit right after the decimal point (the tenth's place) while x[3] and x[4] both contribute to change every digit in the fractional part (.16666 + 0.4167 = .20833 so every digit is different than before). You can't just line up x[0].x[1]x[2]x[3]x[4] and get 1.100000500001666704167, you have to add up each of the terms to get the final result.

To say it a different way : read through the assignment and notice it isn't telling you to keep an array of X values, just one. It's telling you to keep track of exactly two values : the sum so far and 1/N! for the current value of N. Why do you need an array of 5 values plus a sum to hold two items?

Also, does it specifically say 30-35 digits, or 30-35 iterations of the loop (i.e. N can go up to 30)? There's a big difference between the two. There's no reason to assume each iteration series will give you exactly one digit of accuracy. That's easy to see since doing 1 iteration gives you 1 as the result, so you need two iterations to get the first digit correct. If you're supposed to run 30 iterations to get 15 digits that'll fit in a double - no need for arbitrary precision numbers.

So everything is going great until you get to here:

each time the result is calculated, it needs to hold all the numbers after the dot into separate variables like x[1] x[2] x[3] until all the 30~35 digits are filled with them.

which (a) makes no sense and (b) directly contradicts everything before it. Therefore I suspect that sentence to be false.

Thats what it says,
Im supposed to make something that does different calculations and makes them up into one whole 30~35 digit number