| This program converts two roman numerals into integers, performs the user's
choice of calculation, and outputs the answer in roman.
------------------------------------------------------
with Ada.Text_IO;
use Ada.Text_IO;
with Ada.Integer_Text_IO;
use Ada.Integer_Text_IO;
procedure Roman is
-- Declare variables which will be used in main program out here
LEN1 : Integer:=0;
LEN2 : Integer:=0;
MaxRomanLength : CONSTANT integer := 20;
subtype RomanNumeralType is String(1..MaxRomanLength);
RomanNumeral1 : RomanNumeralType;
RomanNumeral2 : RomanNumeralType;
Input1 : Integer:=0;
Input2 : Integer:=0;
UserChoice : Integer:=0;
FinalInteger : Integer:=0;
--------------------------------------------------------------------------------
-- Function for checking Valid Input from the user
-- This function returns a boolean value
Function ValidRomanNumeral (PossibleNumeral : RomanNumeralType) Return
Boolean is
Position : Natural := 1; -- position we are checking in the input
begin -- ValidRomanNumeral
loop
If Position = MaxRomanLength Then
Return True; -- we have reached the maximum length without
problems
Elsif PossibleNumeral(Position) = ' ' Then
Return True; -- we have reached the actual end without
problems
Elsif PossibleNumeral(Position) = 'I' OR
PossibleNumeral(Position) = 'V'
OR PossibleNumeral(Position) = 'X' OR
PossibleNumeral(Position) = 'L'
OR PossibleNumeral(Position) = 'C' OR
PossibleNumeral(Position) = 'D'
OR PossibleNumeral(Position) = 'M' Then
Position := Position + 1;
Else
Return False; -- we have a problem, so return false
end if;
end loop;
-- This will never happen, but it makes the compiler happy.
Return False;
end ValidRomanNumeral;
--------------------------------------------------------------------------------
-- Procedure for getting a valid roman numeral from the user
Procedure GetValidRomanNumeral (RomanNumeral1 : OUT RomanNumeralType;
RomanNumeral2 : OUT RomanNumeralType)
is
Length1 : Natural; -- Number of chars in first entry
Length2 : Natural; -- Number of chars in second entry
begin -- GetValidRomanNumeral
loop
RomanNumeral1 := (others => ' ');
RomanNumeral2 := (others => ' ');
Put(Item =>"Please enter the FIRST Roman numeral: ");
Get_Line(Item => RomanNumeral1, Last => Length1);
Put(Item =>"Please enter the SECOND Roman numeral: ");
Get_Line(Item => RomanNumeral2, Last => Length2);
LEN1 := Length1;
LEN2 := Length2;
-- Code to check the validity of the two user inputs
--exit when ValidRomanNumeral1(PossibleNumeral1 =>
RomanNumeral1); AND
-- ValidRomanNumeral2(PossibleNumeral2 =>
RomanNumeral2);
If ValidRomanNumeral(PossibleNumeral=>RomanNumeral1) then
If ValidRomanNumeral(PossibleNumeral=>RomanNumeral2)
then
Exit;
end if;
end if;
Put(Item => "Please make sure BOTH the Roman Numerals are
valid and try again");
New_Line;
end loop;
end GetValidRomanNumeral;
--------------------------------------------------------------------------------
Function RomanToNatural (RomanNumeral : RomanNumeralType) Return Natural is
Result : Natural := 0; -- result variable
CurrentPosition : Natural := 1; -- the current position in
RomanNumeral being examined.
Value : Integer:=0; -- Value of the corresponding roman numeral
First : Integer:=0;
Next : Integer:=0;
begin --RomanToNatural
ProcessValue: -- Loop to process the appropriate value from the user
Loop
If RomanNumeral(CurrentPosition) = 'M' then
Value := 1000;
elsif RomanNumeral(CurrentPosition) = 'D' then
Value := 500;
elsif RomanNumeral(CurrentPosition) = 'C' then
Value := 100;
elsif RomanNumeral(CurrentPosition) = 'L' then
Value := 50;
elsif RomanNumeral(CurrentPosition) = 'X' then
Value := 10;
elsif RomanNumeral(CurrentPosition) = 'V' then
Value := 5;
elsif RomanNumeral(CurrentPosition) = 'I' then
Value := 1;
elsif RomanNumeral(CurrentPosition) = ' ' then
exit;
end if;
-- If this is the first character then store the value
-- of it in the variable 'First'
If CurrentPosition = 1 then
First := Value;
end if;
Next := Value; -- Store the second value in this variable(2nd
iteration)
-- This is for the second Iteration. Check if the second value
-- is greater than the first value and perform the nescassary
-- steps.
if First < Next then
Result := (Next - First) + (Result - First);
else
Result := Result + Next;
end if;
-- Assign the value of first to next
-- for comparison in later cases
First := Next;
CurrentPosition := CurrentPosition + 1; -- Increment the counter
Variable
--exit when CurrentPosition = (LEN + 1); -- Exit the loop after the
last character is read
end loop ProcessValue; -- End the loop here
Return Result; -- Return the final result to where function is being
called
end RomanToNatural; -- End the function
--------------------------------------------------------------------------------
-- This Function Gets a valid choice from the user
-- The user can chooose to perform arithmetic operations on the
-- Roman numerals. The choices are 1 through 4.
-- Will keep looping till the user gives correct Choice
Procedure GetValidChoice(ValidChoice : OUT Integer)is
Choice : Integer:=1;
begin
BotherUser:
loop
New_Line;
Put("Please choose one of the following operations to be
performed:");
New_line;
Put("1) Add the two Roman Numerals.");
New_line;
Put("2) Subtract the two Roman Numerals.");
New_Line;
Put("3) Multiply the two Roman Numerals.1");
New_Line;
Put("4)Divide the two Roman Numerals.");
New_Line;
Put("----------------------------------------------------");
New_Line;
Put("Please enter choice:");
Ada.Integer_Text_IO.Get(Item=>Choice);
If (choice>0) or (choice<=4) then
exit;
else
New_Line;
Put("Please enter Valid Choice.");
New_Line;
end if;
end loop BotherUser;
ValidChoice := Choice;
end GetValidChoice;
--------------------------------------------------------------------------------
-- This procedure process the valid choice and performs the
-- nescassary calculations on the Two user inputs
Procedure ProcessChoice(UserInput1 : IN Integer;
UserInput2 : IN Integer;
Choice : IN Integer;
Output : OUT Integer) IS
-- Write this procedure in the morning
-- what this essentially does is
-- it takes in userinput1 and userinput2 and Choice as IN Variables
-- According to the user's specified choice we can then compute the
possible
-- values and return Output
-- This value of output will the in turn be stored in a variable called
-- FinalInteger
-- declare variables here
Plus : Integer:=0;
Minus : Integer:=0;
Multiply : Integer:=0;
Divide : Integer:=0;
begin -- ProcessChoice
-- Start checking for user choice and perform nescassary action
If (Choice = 1) then
Plus := UserInput1 + UserInput2;
Output := Plus;
elsif (Choice = 2) then
Minus := UserInput1 - UserInput2;
Output := Minus;
elsif (Choice = 3) then
Multiply := UserInput1 * UserInput2;
Output := Multiply;
elsif (Choice = 4) then
Divide := UserInput1 / UserInput2;
Output := Divide;
else
put("SOMETHING HAS GONE WRONG");
end if;
end ProcessChoice;
-------------------------------------------------------------------------
Procedure ConvertBack(ConvertWhat : IN Integer) is
Value : Integer;
begin
Value := ConvertWhat;
for I in 1..20 loop
if Value<=4000 and Value>=1 then
Ada.Text_Io.Put(Item => "Final Result is:");
while Value>=1000 loop
Ada.Text_Io.Put(Item => "M");
Value:=Value - 1000;
end loop;
while Value>=500 loop
Ada.Text_Io.Put(Item => "D");
Value:=Value - 500;
end loop;
while Value>=100 loop
Ada.Text_Io.Put(Item => "C");
Value:=Value - 100;
end loop;
while Value>=50 loop
Ada.Text_Io.Put(Item => "L");
Value:=Value - 50;
end loop;
while Value>=10 loop
Ada.Text_Io.Put(Item => "X");
Value:=Value - 10;
end loop;
while Value>=5 loop
Ada.Text_Io.Put(Item => "V");
Value:=Value - 5;
end loop;
while Value>=1 loop
Ada.Text_Io.Put(Item => "I");
Value:=Value - 1;
end loop;
end if;
Ada.Text_Io.New_Line;
end loop;
end ConvertBack;
--------------------------------------------------------------------------------
begin -- Procedure Roman
Put("Welcome to the Roman Numeral Calculator program:");
New_Line(2);
-- Get the valid roman numeral from the user
-- This function returns two integer values in RomanInteger1 and
RomanInteger2
-- These values are the corresponding integer values of the entered roman
numerals
GetValidRomanNumeral(RomanNumeral1=>RomanNumeral1,
RomanNumeral2=>RomanNumeral2);
Input1 := RomanToNatural(RomanNumeral=>RomanNumeral1);
Input2 := RomanToNatural(RomanNumeral=>RomanNumeral2);
GetValidChoice(ValidChoice=>UserChoice);
ProcessChoice(UserInput1=>Input1,UserInput2=>Input2,Choice=>UserChoice,Output=>FinalInteger);
ConvertBack(ConvertWhat=>FinalInteger);
end Roman;
|
