457,887 Members | 1,059 Online Need help? Post your question and get tips & solutions from a community of 457,887 IT Pros & Developers. It's quick & easy.

# Division with arrays?

 P: n/a 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. Nov 14 '05 #1
9 Replies

 P: n/a mj***@pf.pl (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/b, a/b, ...), but your arrays are of different lengths (and the 0's in b would cause problems). -- Keith Thompson (The_Other_Keith) ks***@mib.org San Diego Supercomputer Center <*> We must do something. This is something. Therefore, we must do this. Nov 14 '05 #2

 P: n/a 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) .. result = 123456789.123456789; /* handle divide by 0 somehow */ .. else .. result= (double)a/b; ..} 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. Nov 14 '05 #3

 P: n/a 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) . result = 123456789.123456789; /* handle divide by 0 somehow */ . else . result= (double)a/b; .} 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. Nov 14 '05 #4

 P: n/a 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) . result = 123456789.123456789; /* handle divide by 0 somehow */ . else . result= (double)a/b; .} 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. Nov 14 '05 #5

 P: n/a On Tue, 01 Feb 2005 22:12:21 +0000, Keith Thompson wrote: mj***@pf.pl (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/b, a/b, ...), 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 Nov 14 '05 #6

 P: n/a 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 Nov 14 '05 #7

 P: n/a 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 Nov 14 '05 #8

 P: n/a On 1 Feb 2005 13:57:28 -0800, mj***@pf.pl (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 _ 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 Nov 14 '05 #9

 P: n/a Lawrence Kirby writes: On Tue, 01 Feb 2005 22:12:21 +0000, Keith Thompson wrote: mj***@pf.pl (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/b, a/b, ...), 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) ks***@mib.org San Diego Supercomputer Center <*> We must do something. This is something. Therefore, we must do this. Nov 14 '05 #10

### This discussion thread is closed

Replies have been disabled for this discussion. 