8.16 (Huge Integer Class) Create a class HugeInteger which uses a 40-element arr
ID: 638514 • Letter: 8
Question
8.16 (Huge Integer Class) Create a class HugeInteger which uses a 40-element array of digits to
store integers as large as 40 digits each. Provide methods parse, toString, add and subtract. Method
parse should receive a String, extract each digit using method charAt and place the integer
equivalent of each digit into the integer array. For comparing HugeInteger objects, provide the following
methods: isEqualTo, isNotEqualTo, isGreaterThan, isLessThan, isGreaterThanOrEqualTo
and isLessThanOrEqualTo. Each of these is a predicate method that returns true if the relationship
holds between the two HugeInteger objects and returns false if the relationship does not hold. Provide
a predicate method isZero. If you feel ambitious, also provide methods multiply, divide and
remainder. [Note: Primitive boolean values can be output as the word
Explanation / Answer
public class HugeInteger {
private final int DIGITS = 40;
private int[] integer;
private boolean positive;
public HugeInteger()
{
integer = new int[ DIGITS ];
positive = true;
}
// convert a String to HugeInteger
public void input( String inputString )
{
char[] integerChar = inputString.toCharArray();
// check if input is a negative number
if ( integerChar[ 0 ] == '-' )
positive = false;
if ( positive )
integer[ DIGITS - integerChar.length ] =
( int )integerChar[ 0 ] - ( int )'0';
// convert string to integer array
for ( int i = 1; i < integerChar.length; i++ )
integer[ DIGITS - integerChar.length + i ] =
( int )integerChar[ i ] - ( int )'0';
}
// add two HugeIntegers
public HugeInteger add( HugeInteger addValue )
{
HugeInteger temp = new HugeInteger(); // temporary result
// both HugeInteger are positive or negative
if ( ( positive && addValue.positive ) ||
!( positive || addValue.positive ) )
temp = addPositives( addValue );
// addValue is negative
else if ( positive && ( !addValue.positive ) ) {
addValue.positive = true;
if ( isGreatThan( addValue ) )
temp = subtractPositives( addValue );
else {
temp = addValue.subtractPositives( this );
temp.positive = false;
}
addValue.positive = false; // reset sign for addValue
}
// this is negative
else if ( !positive && addValue.positive ) {
addValue.positive = false;
if ( isGreatThan( addValue ) )
temp = addValue.subtractPositives( this );
else {
temp = subtractPositives( addValue );
temp.positive = false;
}
addValue.positive = true; // reset sign for addValue
}
return temp; // return the sum
} // end method add
//add two positive HugeIntegers
public HugeInteger addPositives( HugeInteger addValue )
{
HugeInteger temp = new HugeInteger();
int carry = 0;
// iterate through HugeInteger
for ( int i = 39; i >= 0; i-- ) {
temp.integer[ i ] =
integer[ i ] + addValue.integer[ i ] + carry;
// determine whether to carry a 1
if ( temp.integer[ i ] > 9 ) {
temp.integer[ i ] %= 10; // reduce to 0-9
carry = 1;
}
else
carry = 0;
}
// if both are negative, set the result to negative
if ( !positive )
temp.positive = false;
return temp;
} // end method addPositives
// subtract two HugeIntegers
public HugeInteger subtract( HugeInteger subtractValue )
{
HugeInteger temp = new HugeInteger(); // temporary result
// subtractValue is negative
if ( positive && ( !subtractValue.positive ) )
temp = addPositives( subtractValue );
// this HugeInteger is negative
else if ( !positive && subtractValue.positive ) {
temp = addPositives( subtractValue );
}
// both HugeIntegers are positive
if ( positive && subtractValue.positive )
temp = subtractPositives( subtractValue );
// both HugeIntegers are negative
if ( !( positive || subtractValue.positive ) )
temp = subtractValue.subtractPositives( this );
return temp;
} // end method subtract
//subtract two positive HugeIntegers
public HugeInteger subtractPositives( HugeInteger subtractValue )
{
int borrow = 0;
HugeInteger temp = new HugeInteger();
// iterate through HugeInteger
for ( int i = 39; i >= 0; i-- ) {
// determine to add 10 to smaller integer
if ( integer[i] < subtractValue.integer[ i ] ){
temp.integer[ i ] = ( integer[ i ] + 10 ) -
subtractValue.integer[ i ] - borrow;
borrow = 1; // set borrow to one
}
// if borrowing is not needed
else {
temp.integer[ i ] =
integer[ i ] - subtractValue.integer[ i ] - borrow;
borrow = 0; // set borrow to zero
}
} // end for
return temp; // return difference of two HugeIntegers
} // end method subtractPositives
// find first non-zero position of two HugeIntegers
public int findFirstNonZeroPosition()
{
int position = 39;
// find first non-zero position for first HugeInteger
for ( int i = 0; i < DIGITS; i++ ) {
if ( integer[ i ] > 0 ) {
position = i;
break;
}
}
return position;
} // end method findFirstNonZeroPosition
// get string representation of HugeInteger
public String toHugeIntegerString()
{
String sign = " ", output = " ";
if ( !positive )
sign = "-";
//get HugeInteger values without leading zeros
for ( int i = findFirstNonZeroPosition(); i < DIGITS; i++ )
output += integer[ i ];
return sign + output;
} // end method toHugeIntegerString
// test if two HugeIntegers are equal
public boolean isEqualTo( HugeInteger compareValue )
{
// compare each digit
for ( int i = 0; i < DIGITS; i++ ) {
if ( integer[ i ] != compareValue.integer[ i ] )
return false;
}
// if digits are same, compare the sign
if ( ( positive && compareValue.positive ) ||
!( positive || compareValue.positive ) )
return true;
else
return false;
}
// test if two HugeIntegers are not equal
public boolean isNotEqualTo( HugeInteger compareValue )
{
return !isEqualTo( compareValue );
}
// test if one HugeInteger is greater than another
public boolean isGreatThan( HugeInteger compareValue )
{
// different signs
if ( positive && ( !compareValue.positive ) )
return true;
else if ( !positive && compareValue.positive )
return false;
// same sign
else {
// first number’s length is less than second number’s length
if ( findFirstNonZeroPosition() >
compareValue.findFirstNonZeroPosition() ) {
if ( positive )
return false;
else
return true;
}
//first number’s length is larger than that of second number
else if ( findFirstNonZeroPosition() <
compareValue.findFirstNonZeroPosition() ) {
if ( positive )
return true;
else
return false;
}
// two numbers have same length
else {
for ( int i = 0; i < DIGITS; i++ ) {
if ( integer[ i ] > compareValue.integer[ i ] )
if ( positive )
return true;
else
return false;
}
if ( positive )
return false;
else
return true;
}
} // end outer if-elseif-else
} // end method isGreatThan
// test if one HugeInteger is less than another
public boolean isLessThan( HugeInteger compareValue )
{
return !( isGreatThan( compareValue ) ||
isEqualTo( compareValue ) );
}
// test if one HugeInteger is great than or equal to another
public boolean isGreatThanOrEqualTo( HugeInteger compareValue )
{
return !isLessThan( compareValue );
}
// test if one HugeInteger is less than or equal to another
public boolean isLessThanOrEqualTo( HugeInteger compareValue )
{
return !isGreatThan( compareValue );
}
// test if one HugeInteger is zero
public boolean isZero()
{
// compare each digit
for ( int i = 0; i < DIGITS; i++ ) {
if ( integer[ i ] != 0 )
return false;
}
return true;
}
} // end class HugeInteger
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.