binary division in c require assistance - c

Question

i need help i cant seemed to get the result. the assignment i am doing right now has to do with binary division. the purpose of this project is to try to mimic the ALU and we are not allowed to use the addition or subtraction operator. is there some parts in the code that i am missing?
#include <stdio.h>
#include <math.h>
int subtraction(int operand_1, int operand_2);
int division(int dividen, int divisor);
int addition(int operand_1, int operand_2);
int main()
{
int operand_1, operand_2,res;
printf (" enter the value for operand_1(dividen) and operand_2(divisor): ");
scanf ("%d %d",&operand_1,&operand_2);
res = division(operand_1,operand_2);
printf(" binary division: %d\n\n",res);
}
int addition(int operand_1, int operand_2)
{
int carry = operand_2;
int sum = operand_1;
while (carry !=0)
{
int temp =(sum & carry )<<1;
sum = sum ^ carry;
carry = temp;
}
return sum;
}
int subtraction(int operand_1, int operand_2)
{
operand_2= addition(~operand_2,1);
return addition (operand_1,operand_2);
}
int division ( int dividen, int divisor)
{
int i;
int quotient =0;
for (i= 0; i < 33 ; i++)
{
int remainder = subtraction(remainder,divisor);
if (remainder<0)
{
remainder = addition(divisor, remainder);
quotient= quotient << 1 & 0xfe;
}
else
{
quotient = quotient >> 1 & 0xfe;
}
divisor =divisor >> 1 ;
}
return quotient;
}

Answer 1

Issues with the division() function presented
Function division() initializes its quotient variable to 0. It later performs shift operations on it (quotient >> 1, quotient << 1), and bitwise & operations on the shifted results, but all of these will always produce 0 when quotient is 0. Those results are the only thing ever assigned back to quotient, so the function presented will never return anything other than 0 (unless as a result of exercising undefined behavior).
Moreover, this line is certainly wrong:
int remainder = subtraction(remainder,divisor);
It passes the indeterminate initial value of remainder to the subtraction() function, and uses the undefined result of that as the value of remainder.
And perhaps most telling, the function never uses its dividen parameter.
If your compiler is not producing warnings about the last two, then you would be well advised to learn how to turn up its warning output, or else to find a more helpful compiler. On the other hand, if you are ignoring your compiler's warnings then stop doing that. Compiler warnings are there to help you. Take the time to understand what they are telling you, and fix the problems they describe, or else be sure you can explain why it is safe to ignore them.
Binary long division
Based on the small, fixed bounds of the for loop in the presented division() function and its use of bit shifting, I'm inclined to think that you are specifically trying to implement binary long division. That would be a reasonable way to go, but the details aren't right at all.
is there some parts in the code that i am missing?
It's not a matter of some essential detail having been skipped. Although the algorithm implemented is reminiscent of binary long division, there's pretty much nothing correct about it.
Setting aside the questions of negative inputs and division by zero, binary long division could take this general form:
Convert dividend and divisor to type unsigned int. This gives you an extra value bit to work with, and it gives you defined behavior in relevant cases where [signed] int does not. (See also below.)
Shift the (unsigned) divisor left until it exceeds the (unsigned) dividend, then shift it one bit back right. Let b designate the total number of left shifts performed in that process, which may be zero.
Initialize the working quotient to 0, and the working remainder to the dividend.
Perform the following steps b times:
shift the working quotient one bit left
subtract the (shifted) divisor from the working remainder
if the difference is non-negative then
set the working remainder to the difference
turn on the least-significant bit of the working quotient (equivalently, add 1 to the quotient)
(else the difference is negative. The working remainder should not be updated, and the corresponding quotient bit is (already) zero).
shift the divisor one bit right.
After the iterations are finished, the working quotient is the correct binary quotient (of the unsigned operands), and the working remainder is the remainder, as would be computed by the % operator.
Note that although the bit-shifting disguises it somewhat, this is the same long division algorithm you learned in grade school, simplified by the fact that 1 and 0 are the only digits to be concerned with.
If your function must handle negative inputs then the initial conversion to unsigned must capture information about their signs and yield their absolute values. The sign information will inform whether the quotient needs to be inverted at the end.
I have intentionally avoided writing actual C code for the division function, so as not to rob you of the instructional value of writing that code yourself. I would encourage you, moreover, to study the algorithm description until you understand what it's doing and why, and then attempt to rewrite your division() function without referring further to this answer.

Answer 2

This works. I check for operators sign, if both are - result will be +.
Btw, your keyboard input doesnt work fine for 2 negative values, probably it is better in 2 different lines, in 2 scanfs.
int division ( int dividen, int divisor)
{
char sign=0;
int i;
int quotient =0;
int remainder=dividen;
if(dividen<0)
{
dividen=addition(~dividen,1);
sign^=1;
}
if(divisor<0)
{
divisor=addition(~divisor,1);
sign^=1;
}
do
{
printf("%d %d\r\n ",quotient ,remainder);
if (remainder>=divisor)
{
quotient= addition(quotient,1);
remainder=subtraction(remainder,divisor);
}
}while(remainder>=divisor);
if(sign)
quotient=addition(~quotient,1);
return quotient;
}