Step by Step solution about How to resolve the algorithm Tropical algebra overloading step by step in the Java programming language

This Java program operates on tropical numbers, a mathematical concept commonly employed in optimization and decision-making. Tropical numbers belong to a special algebraic structure where addition and multiplication operations differ from their conventional counterparts.

Key Concepts:

• Tropical Number: A tropical number can be either a finite real number or negative infinity (-Inf).

Class Structure:

• TropicalAlgebra (main class): Contains the main method and several test cases for demonstrating tropical operations.

• Tropical (inner class): Represents a tropical number. It has the following features:

  • Constructor: Takes an optional Number object as input, representing a finite tropical number. If no argument is provided, it defaults to negative infinity.
  • toString(): Returns a string representation of the tropical number. For finite numbers, it truncates the decimal part. For negative infinity, it returns "-Inf".
  • add(): Performs tropical addition, returning the larger of the two numbers (or negative infinity if either is negative infinity).
  • multiply(): Performs tropical multiplication, equivalent to adding the two numbers.
  • power(): Computes the tropical power of the number, repeating the multiplication operation a specified number of times.

Main Method:

The main method creates instances of Tropical objects and demonstrates various operations:

• Addition and multiplication of finite tropical numbers
• Addition of a finite number and negative infinity
• Multiplication of 0 and negative infinity
• Tropical exponentiation

Test Cases:

The test cases verify the expected behavior of tropical operations:

• Addition: g.add(a) results in negative infinity because a is less than g.
• Addition with negative infinity: d.add(k) results in negative infinity since adding any number to negative infinity remains negative infinity.
• Multiplication with 0: e.multiply(k) results in negative infinity because multiplying any number by negative infinity yields negative infinity.
• Addition of finite numbers: f.add(b) gives 1.5 + (-1) = 1.5, as expected.
• Multiplication of 0 with a finite number: c.multiply(e) yields negative infinity because multiplying 0 by any finite number results in negative infinity.
• Exponentiation: h.power(7) calculates 5^7 = 5 * 5 * 5 * 5 * 5 * 5 * 5 = 78,125, which is simplified to "78125" in the output.
• Distributivity: h.multiply(j.add(i)) and h.multiply(j).add(h.multiply(i)) both evaluate to the same result, illustrating the distributivity property of tropical multiplication.

import java.util.Optional;

public final class TropicalAlgebra {

	public static void main(String[] aArgs) {
		final Tropical a = new Tropical(-2);
		final Tropical b = new Tropical(-1);
		final Tropical c = new Tropical(-0.5);
		final Tropical d = new Tropical(-0.001);
		final Tropical e = new Tropical(0);
		final Tropical f = new Tropical(1.5);
		final Tropical g = new Tropical(2);
		final Tropical h = new Tropical(5);
		final Tropical i = new Tropical(7);
		final Tropical j = new Tropical(8);
		final Tropical k = new Tropical();
		
		System.out.println("2 x -2 = " + g.multiply(a));
		System.out.println("-0.001 + -Inf = " + d.add(k));
		System.out.println("0 x -Inf = " + e.multiply(k));
		System.out.println("1.5 + -1 = " + f.add(b));
		System.out.println("-0.5 x 0 = " + c.multiply(e));
		
		System.out.println();
		System.out.println("5^7 = " + h.power(7));		
		
		System.out.println();
		System.out.println("5 * ( 8 + 7 ) = " + h.multiply(j.add(i)));
		System.out.println("5 * 8 + 5 * 7 = " + h.multiply(j).add(h.multiply(i)));		
	}

}

final class Tropical {
	
	public Tropical(Number aNumber) {
		if ( aNumber == null ) {
			throw new IllegalArgumentException("Number cannot be null");
		}
		
		optional = Optional.of(aNumber);
	}
	
	public Tropical() {
		optional = Optional.empty();
	}
	
	@Override
	public String toString() {
		if ( optional.isEmpty() ) {
			return "-Inf";
		}
	
		String value = String.valueOf(optional.get());
		final int index = value.indexOf(".");
		if ( index >= 0 ) {
			value = value.substring(0, index);
		}
		
		return value;
	}
	
	public Tropical add(Tropical aOther) {
		if ( aOther.optional.isEmpty() ) {
			return this;
		}
		
		if ( optional.isEmpty() ) {
			return aOther;
		}
		
		if ( optional.get().doubleValue() > aOther.optional.get().doubleValue() ) {
			return this;
		}		
		return aOther;
	}
	
	public Tropical multiply(Tropical aOther) {
		if ( optional.isPresent() && aOther.optional.isPresent() ) {
			double result = optional.get().doubleValue() + aOther.optional.get().doubleValue();			
			return new Tropical(result);
		}
		
		return new Tropical();
	}
	
	public Tropical power(int aExponent) {
		if ( aExponent <= 0 ) {
			throw new IllegalArgumentException("Power must be positive");
		}
		
		Tropical result = this;;
	    for ( int i = 1; i < aExponent; i++ ) {
	        result = result.multiply(this);
	    }
	    
	    return result;
	}
	
	private Optional<Number> optional;
	
}