Add 4 20 digit numbers in C

[thehobbit]

Hi,

Could anyone give ideas on how to add 4 20 digit numbers in ANSI C and
pass the result back to a calling program in COBOL? We were able to
add up to 15 digit numbers without any problems, but we started facing
issues once we go above 15 digits.

Thanks,
Venkat

[CBFalconer]

thehobbit wrote:

>
Thank you for the details jack... actually am a nincompoop in C...
more of a COBOL programmer... actually what we are trying to do is
add 4 20 digit integers and return the sum back to the COBOL
program. This is because COBOL has a limitation of 18 digits. When
we added 15 4 digit integer numbers we got the expected sum,
however the moment we started adding 16 4 digit integers then the
sum was all wrong... the code we kind of wrote is as follows;
Please let us know if you have any suggestions...

Top-posting has lost all the previous content. Please avoid it.

You are not adding integers - you are adding strings. Your problem
is double. First arrange to cleanly limit the input strings, i.e.
detect the rightmost and leftmost digits in each. Then you can
simply perform sequential addition, adding individual digits and
propagating carries. You have to be able to drop propagation past
the most significant digit of the input.

Please do not top-post. Your answer belongs after (or intermixed
with) the quoted material to which you reply, after snipping all
irrelevant material. See the following links:

--
<http://www.catb.org/~esr/faqs/smart-questions.html>
<http://www.caliburn.nl/topposting.html >
<http://www.netmeister. org/news/learn2quote.htm l>
<http://cfaj.freeshell. org/google/ (taming google)
<http://members.fortune city.com/nnqweb/ (newusers)

--
Posted via a free Usenet account from http://www.teranews.com

[Willem]

thehobbit wrote:
) Thank you for the details jack... actually am a nincompoop in C...
) more of a COBOL programmer... actually what we are trying to do is add
) 4 20 digit integers and return the sum back to the COBOL program. This
) is because COBOL has a limitation of 18 digits. When we added 15 4
) digit integer numbers we got the expected sum, however the moment we
) started adding 16 4 digit integers then the sum was all wrong... the
) code we kind of wrote is as follows; Please let us know if you have
) any suggestions...

Can't you roll your own bignum function in cobol ?
That is, one that adds four 'strings' together that consist of difits.
I mean, just adding numbers is quite easy.

Here's a snippet in C that does the same.
I'm sure you can easily rewrite that to COBOL.
It could even be made a lot simpler by right-aligning the numbers,
so you don't first have to find the length.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
* Function to add 4 integers
* Assumes the integers contain only digits '0' through '9'.
*/

void ccadd(char *inp1,char *inp2,char *inp3,char *inp4,char *out)
{
int res;
size_t i1, i2, i3, i4, io;

i1 = strlen(inp1);
i2 = strlen(inp2);
i3 = strlen(inp3);
i4 = strlen(inp4);
io = i1;
if (i2 io) io = i2;
if (i3 io) io = i3;
if (i4 io) io = i4;
io = io + 1;

out[io] = 0;
res = 0;

while (io 0) {
if (i1 0) res += (inp1[--i1] - '0');
if (i2 0) res += (inp2[--i2] - '0');
if (i3 0) res += (inp3[--i3] - '0');
if (i4 0) res += (inp4[--i4] - '0');
out[--io] = (res % 10) + '0';
res = res / 10;
}
}

SaSW, Willem
--
Disclaimer: I am in no way responsible for any of the statements
made in the above text. For all I know I might be
drugged or something..
No I'm not paranoid. You all think I'm paranoid, don't you !
#EOT

[Tor Rustad]

thehobbit wrote:

Hi,

Could anyone give ideas on how to add 4 20 digit numbers in ANSI C and
pass the result back to a calling program in COBOL? We were able to
add up to 15 digit numbers without any problems, but we started facing
issues once we go above 15 digits.

Using an old COBOL compiler?

I while back, I took a look at IBM's decNumber C library:

http://www2.hursley.ibm.com/decimal/decnumber.html

which provide an implementation of the upcoming IEEE 754 revision. I
haven't used it yet, but if there are issues with the library, there are
tons of multi-precision C packages out there, see e.g. GNU GMP.

How to interface, COBOL and C, is specified in your platform doc, we
cannot tell.

--
Tor <bw****@wvtqvm. vw | tr i-za-h a-z>

[Charlie Gordon]

"thehobbit" <ve**********@g mail.coma écrit dans le message de news:
11************* ********@k35g20 00...legro ups.com...

>
Thank you for the details jack... actually am a nincompoop in C...
more of a COBOL programmer... actually what we are trying to do is add
4 20 digit integers and return the sum back to the COBOL program. This
is because COBOL has a limitation of 18 digits. When we added 15 4
digit integer numbers we got the expected sum, however the moment we
started adding 16 4 digit integers then the sum was all wrong... the
code we kind of wrote is as follows; Please let us know if you have
any suggestions...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
* Function to add 4 integers
*/

void ccadd(char *inp1,char *inp2,char *inp3,char *inp4,char *out)
{
long long int_inp1,int_in p2,int_inp3,int _inp4,int_out;
int_inp1 = atoi(inp1);
int_inp2 = atoi(inp2);
int_inp3 = atoi(inp3);
int_inp4 = atoi(inp4);

You should use atoll or stroll for these conversions if the numbers can
exceed INT_MAX

int_out = int_inp1 + int_inp2 + int_inp3 + int_inp4;
sprintf(out,"%l f",int_out);

Here you are using the wrong format: it should be %lld assuming your C
library supports long long
Also there is no guarantee the result of the conversion will "fit" in the
destination buffer ``out''.

}

The format error may well be the source of your problem, but the solution
posted by Willem is more general, as it can handle numbers of any size
(still assuming the destination is large enough)

--
Chqrlie.

[user923005]

On Nov 7, 10:13 pm, thehobbit <venkat.na...@g mail.comwrote:

Thank you for the details jack... actually am a nincompoop in C...
more of a COBOL programmer... actually what we are trying to do is add
4 20 digit integers and return the sum back to the COBOL program. This
is because COBOL has a limitation of 18 digits. When we added 15 4
digit integer numbers we got the expected sum, however the moment we
started adding 16 4 digit integers then the sum was all wrong... the
code we kind of wrote is as follows; Please let us know if you have
any suggestions...

The reason that COBOL has a limit of 18 digits is because the data
type has a limit of 18 digits.
A long long integer (or unsigned long long) generally consumes 8 bytes
of memory storage.
That means that you can store {typically} 2^64-1 in an unsigned long
long. Let's see what it looks like:
unsigned limit = 184467440737095 51615 (We are unable to store
999999999999999 99999 so 19 digits precision)
signed limit = 922337203685477 5807 (We are unable to store
999999999999999 9999 so 18 digits of precision)

C probably will not have any more success than COBOL at adding your
numbers together, because if they overflow in COBOL then they will
overflow in C.

So the real question is, "What is the exact problem that you are
trying to solve?" Chances are very good that the problem can be
solved in either COBOL or C or both.

If you need to store a 20 digit number in a comp type that occupies 8
bytes, then often you will meet with serious disappointment.
So what we need to know is, is this a total for a report? Is it a
value to be posted back to the database? Exactly what is the purpose
of the new total?
Once we know that, then you can decide on an algorithm to solve the
problem or a new data type for the database, or whatever.

Probably, your posts are more topical in news:comp.progr amming

[snip]