AdaPower Logged in as Guest
Ada Tools and Resources

Ada 95 Reference Manual
Ada Source Code Treasury
Bindings and Packages
Ada FAQ


Join >
Home >
Articles >
Getting Started >
Ada FAQ >
Source Treasury >
Books & Tutorials >
Packages for Reuse >
Latest Additions >
Ada Projects >
Press Releases >
Ada Audio / Video >
Home Pages >
Links >
Contact >
About >
Login >
Back
Perform operations on Roman numerals (Samir)

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;  


(c) 1998-2004 All Rights Reserved David Botton