Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > Division with arrays?

Reply
Thread Tools

Division with arrays?

 
 
Marcin
Guest
Posts: n/a
 
      02-01-2005
How I can make division of two numbers placed in arrays, example:

short int a[] = {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
short int b[] = {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};

short int result[] = a / b; 'division

without additional lib's and header files, only in standart C.
 
Reply With Quote
 
 
 
 
Keith Thompson
Guest
Posts: n/a
 
      02-01-2005
http://www.velocityreviews.com/forums/(E-Mail Removed) (Marcin) writes:
> How I can make division of two numbers placed in arrays, example:
>
> short int a[] = {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
> short int b[] = {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
>
> short int result[] = a / b; 'division
>
> without additional lib's and header files, only in standart C.


First, define what you mean by division for arrays. The most obvious
meaning result would be an array consisting of the result of dividing
each element in turn (a[0]/b[0], a[1]/b[1], ...), but your arrays are
of different lengths (and the 0's in b would cause problems).

--
Keith Thompson (The_Other_Keith) (E-Mail Removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
 
Reply With Quote
 
 
 
 
Kobu
Guest
Posts: n/a
 
      02-01-2005

Marcin wrote:
> How I can make division of two numbers placed in arrays, example:
>
> short int a[] =

{2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
> short int b[] =

{1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
>
> short int result[] = a / b; 'division
>
> without additional lib's and header files, only in standart C.


You have to manually do this (go through pairs of elements - one in
each array). You're arrays are of different sizes, so your result
array will be the size of the shorter array (and division by zero has
to be handled).

example (assuming your declarations for array 'a' and 'b' are done):

..double *result;
..size_t i;

..size_t limit = (sizeof(a)/sizeof(*a) > sizeof(b)/sizeof(*b)) :
sizeof(a)/sizeof(*a) ? sizeof(b)/sizeof(*b);

..result = malloc(sizeof(*result) * limit);

/* loop below divides elements of 'a' by 'b' places into result */
..for(i = 0; i < limit; i++)
..{
.. if(b[0] = 0)
.. result[0] = 123456789.123456789; /* handle divide by 0 somehow
*/
.. else
.. result[0]= (double)a[0]/b[0];
..}

At this point, the division is done, and you have a dynamically
allocated buffer (which you can reference like an array) result, which
holds the division results for each element. You have to handle
division by zero somehow, possible choosing some value that can't be
the result of your divisions.

When you're done with the result array you have to free the buffer
using:

free(result);

Otherwise, you have a memory leak.

 
Reply With Quote
 
Kobu
Guest
Posts: n/a
 
      02-02-2005

Kobu wrote:
> Marcin wrote:
> > How I can make division of two numbers placed in arrays, example:
> >
> > short int a[] =

> {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
> > short int b[] =

> {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
> >
> > short int result[] = a / b; 'division
> >
> > without additional lib's and header files, only in standart C.

>
> You have to manually do this (go through pairs of elements - one in
> each array). You're arrays are of different sizes, so your result
> array will be the size of the shorter array (and division by zero has
> to be handled).
>
> example (assuming your declarations for array 'a' and 'b' are done):
>
> .double *result;
> .size_t i;
>
> .size_t limit = (sizeof(a)/sizeof(*a) > sizeof(b)/sizeof(*b)) :
> sizeof(a)/sizeof(*a) ? sizeof(b)/sizeof(*b);
>
> .result = malloc(sizeof(*result) * limit);
>
> /* loop below divides elements of 'a' by 'b' places into result */
> .for(i = 0; i < limit; i++)
> .{
> . if(b[0] = 0)
> . result[0] = 123456789.123456789; /* handle divide by 0

somehow
> */
> . else
> . result[0]= (double)a[0]/b[0];
> .}


all the subscripts within the loop should be i, not 0

>
> At this point, the division is done, and you have a dynamically
> allocated buffer (which you can reference like an array) result,

which
> holds the division results for each element. You have to handle
> division by zero somehow, possible choosing some value that can't be
> the result of your divisions.
>
> When you're done with the result array you have to free the buffer
> using:
>
> free(result);
>
> Otherwise, you have a memory leak.


 
Reply With Quote
 
Luke Wu
Guest
Posts: n/a
 
      02-02-2005

Kobu wrote:
> Kobu wrote:
> > Marcin wrote:
> > > How I can make division of two numbers placed in arrays, example:
> > >
> > > short int a[] =

> > {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
> > > short int b[] =

> > {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
> > >
> > > short int result[] = a / b; 'division
> > >
> > > without additional lib's and header files, only in standart C.

> >
> > You have to manually do this (go through pairs of elements - one in
> > each array). You're arrays are of different sizes, so your result
> > array will be the size of the shorter array (and division by zero

has
> > to be handled).
> >
> > example (assuming your declarations for array 'a' and 'b' are

done):
> >
> > .double *result;
> > .size_t i;
> >
> > .size_t limit = (sizeof(a)/sizeof(*a) > sizeof(b)/sizeof(*b)) :
> > sizeof(a)/sizeof(*a) ? sizeof(b)/sizeof(*b);


the expression to the right of the = operator evaluates to a compile
time constant, which you can use to statically or automatically
allocate a result array (if you wanted to)

> >
> > .result = malloc(sizeof(*result) * limit);
> >
> > /* loop below divides elements of 'a' by 'b' places into result */
> > .for(i = 0; i < limit; i++)
> > .{
> > . if(b[0] = 0)
> > . result[0] = 123456789.123456789; /* handle divide by 0

> somehow
> > */
> > . else
> > . result[0]= (double)a[0]/b[0];
> > .}

>
> all the subscripts within the loop should be i, not 0
>
> >
> > At this point, the division is done, and you have a dynamically
> > allocated buffer (which you can reference like an array) result,

> which
> > holds the division results for each element. You have to handle
> > division by zero somehow, possible choosing some value that can't

be
> > the result of your divisions.
> >
> > When you're done with the result array you have to free the buffer
> > using:
> >
> > free(result);
> >
> > Otherwise, you have a memory leak.


 
Reply With Quote
 
Lawrence Kirby
Guest
Posts: n/a
 
      02-02-2005
On Tue, 01 Feb 2005 22:12:21 +0000, Keith Thompson wrote:

> (E-Mail Removed) (Marcin) writes:
>> How I can make division of two numbers placed in arrays, example:
>>
>> short int a[] = {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
>> short int b[] = {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
>>
>> short int result[] = a / b; 'division
>>
>> without additional lib's and header files, only in standart C.

>
> First, define what you mean by division for arrays. The most obvious
> meaning result would be an array consisting of the result of dividing
> each element in turn (a[0]/b[0], a[1]/b[1], ...), but your arrays are
> of different lengths (and the 0's in b would cause problems).


The question did state that theree are 2 numbers, so presumable each array
a and b represents a number in some fashion. We don't know how but at a
guess it is probably as a sequence of decimal digits. In which case some
form of decimal long division looks appropriate.

Lawrence

 
Reply With Quote
 
Lawrence Kirby
Guest
Posts: n/a
 
      02-02-2005
On Tue, 01 Feb 2005 15:52:06 -0800, Kobu wrote:

>
> Marcin wrote:
>> How I can make division of two numbers placed in arrays, example:
>>
>> short int a[] =

> {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
>> short int b[] =

> {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
>>
>> short int result[] = a / b; 'division
>>
>> without additional lib's and header files, only in standart C.

>
> You have to manually do this (go through pairs of elements - one in
> each array). You're arrays are of different sizes, so your result
> array will be the size of the shorter array (and division by zero has
> to be handled).


1000 / 1 is 1000, i.e. the result is not the size of the "shorter array".
If there are no leading zeros in the numbers it would be
nelems(a)-nelems(b)+1, and if b is larger the result is trivially zero.

> example (assuming your declarations for array 'a' and 'b' are done):
>
> .double *result;
> .size_t i;
>
> .size_t limit = (sizeof(a)/sizeof(*a) > sizeof(b)/sizeof(*b)) :
> sizeof(a)/sizeof(*a) ? sizeof(b)/sizeof(*b);


Here you are using the number of elements of the larger of the 2 arrays
which would work but isn't optimal. You might just as well use simply the
number of elements of a, the result of a valid integer division can't be
larger than the dividend.

Lawrence

 
Reply With Quote
 
Kobu
Guest
Posts: n/a
 
      02-02-2005

Lawrence Kirby wrote:
> On Tue, 01 Feb 2005 15:52:06 -0800, Kobu wrote:
>
> >
> > Marcin wrote:
> >> How I can make division of two numbers placed in arrays, example:
> >>
> >> short int a[] =

> > {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
> >> short int b[] =

> > {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
> >>
> >> short int result[] = a / b; 'division
> >>
> >> without additional lib's and header files, only in standart C.

> >
> > You have to manually do this (go through pairs of elements - one in
> > each array). You're arrays are of different sizes, so your result
> > array will be the size of the shorter array (and division by zero

has
> > to be handled).

>
> 1000 / 1 is 1000, i.e. the result is not the size of the "shorter

array".
> If there are no leading zeros in the numbers it would be
> nelems(a)-nelems(b)+1, and if b is larger the result is trivially

zero.

by size I mean: sizeof(array)/sizeof(*array)
I think I misunderstood the question, thinking that each array held a
separate number in each position. I now see what he probably meant.

>
> > example (assuming your declarations for array 'a' and 'b' are

done):
> >
> > .double *result;
> > .size_t i;
> >
> > .size_t limit = (sizeof(a)/sizeof(*a) > sizeof(b)/sizeof(*b)) :
> > sizeof(a)/sizeof(*a) ? sizeof(b)/sizeof(*b);


should be < not > (under my original assumption)

>
> Here you are using the number of elements of the larger of the 2

arrays
> which would work but isn't optimal. You might just as well use simply

the
> number of elements of a, the result of a valid integer division can't

be
> larger than the dividend.


yeap, good point

>
> Lawrence


 
Reply With Quote
 
Kevin D. Quitt
Guest
Posts: n/a
 
      02-02-2005
On 1 Feb 2005 13:57:28 -0800, (E-Mail Removed) (Marcin) wrote:


>How I can make division of two numbers placed in arrays, example:
>
>short int a[] = {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
>short int b[] = {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
>
>short int result[] = a / b; 'division


Is b's value 10000000000000000000000002 or 20000000000000000000000001 ?
If it's the latter, the problem is very simple. If not, it's very
slightly more complicated.


--
#include <standard.disclaimer>
_
Kevin D Quitt USA 91387-4454 96.37% of all statistics are made up
Per the FCA, this address may not be added to any commercial mail list
 
Reply With Quote
 
Keith Thompson
Guest
Posts: n/a
 
      02-02-2005
Lawrence Kirby <(E-Mail Removed)> writes:
> On Tue, 01 Feb 2005 22:12:21 +0000, Keith Thompson wrote:
>
>> (E-Mail Removed) (Marcin) writes:
>>> How I can make division of two numbers placed in arrays, example:
>>>
>>> short int a[] = {2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 ,1,1,1,2};
>>> short int b[] = {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 ,2};
>>>
>>> short int result[] = a / b; 'division
>>>
>>> without additional lib's and header files, only in standart C.

>>
>> First, define what you mean by division for arrays. The most obvious
>> meaning result would be an array consisting of the result of dividing
>> each element in turn (a[0]/b[0], a[1]/b[1], ...), but your arrays are
>> of different lengths (and the 0's in b would cause problems).

>
> The question did state that theree are 2 numbers, so presumable each array
> a and b represents a number in some fashion. We don't know how but at a
> guess it is probably as a sequence of decimal digits. In which case some
> form of decimal long division looks appropriate.


Ok, that's probably what the OP meant, but he needs to clarify it. Do
the arrays represent sequences of decimal digits? In what order? How
are negative values represented (are only non-negative values
representable).

--
Keith Thompson (The_Other_Keith) (E-Mail Removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
division by 7 without using division operator krypto.wizard@gmail.com C Programming 94 02-09-2007 06:57 AM
SRT DIvision, Square root and reciprocal square root alghazo@siu.edu VHDL 0 05-27-2004 06:23 AM
polynomial division remainder Manfred Balik VHDL 5 05-18-2004 02:37 AM
FLOATING POINT DIVISION sunwij VHDL 3 12-29-2003 04:44 AM
will Synposys Design Compiler support division by two's power and integer rounding? walala VHDL 12 09-14-2003 03:49 PM



Advertisments