Strongly typed language

Colors

Goal: create a package to represent HTML colors in hexadecimal form and its corresponding names.

Steps:

1. Implement the Color_Types package.

   1. Declare the HTML_Color enumeration.

   2. Declare the Basic_HTML_Color enumeration.

   3. Implement the To_Integer function.

   4. Implement the To_HTML_Color function.

Requirements:

1. Enumeration HTML_Color has the following colors:

   • Salmon

   • Firebrick

   • Red

   • Darkred

   • Lime

   • Forestgreen

   • Green

   • Darkgreen

   • Blue

   • Mediumblue

   • Darkblue

2. Enumeration Basic_HTML_Color has the following colors: Red, Green, Blue.

3. Function To_Integer converts from the HTML_Color type to the HTML color code — as integer values in hexadecimal notation.

   • You can find the HTML color codes in the table below.

4. Function To_HTML_Color converts from Basic_HTML_Color to HTML_Color.

5. This is the table to convert from an HTML color to a HTML color code in hexadecimal notation:

Color	HTML color code (hexa)
Salmon	#FA8072
Firebrick	#B22222
Red	#FF0000
Darkred	#8B0000
Lime	#00FF00
Forestgreen	#228B22
Green	#008000
Darkgreen	#006400
Blue	#0000FF
Mediumblue	#0000CD
Darkblue	#00008B

Remarks:

1. In order to express the hexadecimal values above in Ada, use the following syntax: 16#<hex_value># (e.g.: 16#FFFFFF#).

2. For function To_Integer, you may use a case for this.

    
        
in 0:HTML_Color_Range
out 0:SALMON FIREBRICK RED DARKRED LIME FORESTGREEN GREEN DARKGREEN BLUE MEDIUMBLUE DARKBLUE
in 1:HTML_Color_To_Integer
out 1:16#FA8072# 16#B22222# 16#FF0000# 16#8B0000# 16#FF00# 16#228B22# 16#8000# 16#6400# 16#FF# 16#CD# 16#8B#
in 2:Basic_HTML_Color_To_HTML_Color
out 2:RED GREEN BLUE
    
    
    
        
package Color_Types is

   --  Include type declaration for HTML_Color!
   --
   --  type HTML_Color is [...]
   --

   --  Include function declaration for:
   --  function To_Integer (C : HTML_Color) return Integer;

   --  Include type declaration for Basic_HTML_Color!
   --
   --  type Basic_HTML_Color is [...]
   --

   --  Include function declaration for:
   --  - Basic_HTML_Color => HTML_Color
   --
   --  function To_HTML_Color [...];
   --
end Color_Types;
    
        
package body Color_Types is

   --  Implement the conversion from HTML_Color to Integer here!
   --
   --  function To_Integer (C : HTML_Color) return Integer is
   --  begin
   --  --  Hint: use 'case' for the HTML colors;
   --  --        use 16#...# for the hexadecimal values.
   --  end To_Integer;

   --  Implement the conversion from Basic_HTML_Color to HTML_Color here!
   --
   --  function To_HTML_Color [...] is
   --
end Color_Types;
    
        
with Ada.Command_Line; use Ada.Command_Line;
with Ada.Text_IO;      use Ada.Text_IO;
with Ada.Integer_Text_IO;

with Color_Types; use Color_Types;

procedure Main is
   type Test_Case_Index is
     (HTML_Color_Range,
      HTML_Color_To_Integer,
      Basic_HTML_Color_To_HTML_Color);

   procedure Check (TC : Test_Case_Index) is
   begin
      case TC is
         when HTML_Color_Range =>
            for I in HTML_Color'Range loop
               Put_Line (HTML_Color'Image (I));
            end loop;
         when HTML_Color_To_Integer =>
            for I in HTML_Color'Range loop
               Ada.Integer_Text_IO.Put (Item  => To_Integer (I),
                                        Width => 6,
                                        Base  => 16);
               New_Line;
            end loop;
         when Basic_HTML_Color_To_HTML_Color =>
            for I in Basic_HTML_Color'Range loop
               Put_Line (HTML_Color'Image (To_HTML_Color (I)));
            end loop;
      end case;
   end Check;

begin
   if Argument_Count < 1 then
      Put_Line ("ERROR: missing arguments! Exiting...");
      return;
   elsif Argument_Count > 1 then
      Put_Line ("Ignoring additional arguments...");
   end if;

   Check (Test_Case_Index'Value (Argument (1)));
end Main;
    
    

        
            color_types.ads
        
            color_types.adb
        
            main.adb
        
    
    

    

        

            
                
                Settings
            
            

                
                    
                    Enable tabbed editor view for this editor
                
                
                    
                    Use the dark theme
                
            
        
        
            
            Reset
        
        
            
            Download
        
    
    

        

            
                Submit
            
        
        

            

            
                

            
        
    

Integers

Goal: implement a package with various integer types.

Steps:

1. Implement the Int_Types package.

   1. Declare the integer type I_100.

   2. Declare the modular type U_100.

   3. Implement the To_I_100 function to convert from the U_100 type.

   4. Implement the To_U_100 function to convert from the I_100 type.

   5. Declare the derived type D_50.

   6. Declare the subtype S_50.

   7. Implement the To_D_50 function to convert from the I_100 type.

   8. Implement the To_S_50 function to convert from the I_100 type.

   9. Implement the To_I_100 function to convert from the D_50 type.

Requirements:

1. Types I_100 and U_100 have values between 0 and 100.

   1. Type I_100 is an integer type.

   2. Type U_100 is a modular type.

2. Function To_I_100 converts from the U_100 type to the I_100 type.

3. Function To_U_100 converts from the I_100 type to the U_100 type.

4. Types D_50 and S_50 have values between 10 and 50 and use I_100 as a base type.

   1. D_50 is a derived type.

   2. S_50 is a subtype.

5. Function To_D_50 converts from the I_100 type to the D_50 type.

6. Function To_S_50 converts from the I_100 type to the S_50 type.

7. Functions To_D_50 and To_S_50 saturate the input values if they are out of range.

   • If the input is less than 10 the output should be 10.

   • If the input is greater than 50 the output should be 50.

8. Function To_I_100 converts from the D_50 type to the I_100 type.

Remarks:

1. For the implementation of functions To_D_50 and To_S_50, you may use the type attributes D_50'First and D_50'Last:

   1. D_50'First indicates the minimum value of the D_50 type.

   2. D_50'Last indicates the maximum value of the D_50 type.

   3. The same attributes are available for the S_50 type ( S_50'First and S_50'Last).

2. We could have implemented a function To_I_100 as well to convert from S_50 to I_100. However, we skip this here because explicit conversions are not needed for subtypes.

    
        
in 0:I_100_Range
out 0:0 100
in 1:U_100_Range
out 1:0 100
in 2:U_100_Wraparound
out 2:100 0
in 3:U_100_To_I_100
out 3:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
in 4:I_100_To_U_100
out 4:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
in 5:D_50_Range
out 5:10 50
in 6:S_50_Range
out 6:10 50
in 7:I_100_To_D_50
out 7:10 10 10 10 10 10 10 10 10 10 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50
in 8:I_100_To_S_50
out 8:10 10 10 10 10 10 10 10 10 10 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50 50
in 9:D_50_To_I_100
out 9:10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
in 10:S_50_To_I_100
out 10:10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
    
    
    
        
package Int_Types is

   --  Include type declarations for I_100 and U_100!
   --
   --  type I_100 is [...]
   --  type U_100 is [...]
   --

   function To_I_100 (V : U_100) return I_100;

   function To_U_100 (V : I_100) return U_100;

   --  Include type declarations for D_50 and S_50!
   --
   --  [...] D_50 is [...]
   --  [...] S_50 is [...]
   --

   function To_D_50 (V : I_100) return D_50;

   function To_S_50 (V : I_100) return S_50;

   function To_I_100 (V : D_50) return I_100;

end Int_Types;
    
        
package body Int_Types is

   function To_I_100 (V : U_100) return I_100 is
   begin
      --  Implement the conversion from U_100 to I_100 here!
      --
      null;
   end To_I_100;

   function To_U_100 (V : I_100) return U_100 is
   begin
      --  Implement the conversion from I_100 to U_100 here!
      --
      null;
   end To_U_100;

   function To_D_50 (V : I_100) return D_50 is
      Min : constant I_100 := I_100 (D_50'First);
      Max : constant I_100 := I_100 (D_50'Last);
   begin
      --  Implement the conversion from I_100 to D_50 here!
      --
      --  Hint: using the constants above simplifies the checks needed for
      --        this function.
      --
      null;
   end To_D_50;

   function To_S_50 (V : I_100) return S_50 is
   begin
      --  Implement the conversion from I_100 to S_50 here!
      --
      --  Remark: don't forget to verify whether an explicit conversion like
      --          S_50 (V) is needed.
      --
      null;
   end To_S_50;

   function To_I_100 (V : D_50) return I_100 is
   begin
      --  Implement the conversion from I_100 to D_50 here!
      --
      --  Remark: don't forget to verify whether an explicit conversion like
      --          I_100 (V) is needed.
      --
      null;
   end To_I_100;

end Int_Types;
    
        
with Ada.Command_Line; use Ada.Command_Line;
with Ada.Text_IO;      use Ada.Text_IO;

with Int_Types;        use Int_Types;

procedure Main is
   package I_100_IO is new Ada.Text_IO.Integer_IO (I_100);
   package U_100_IO is new Ada.Text_IO.Modular_IO (U_100);
   package D_50_IO  is new Ada.Text_IO.Integer_IO (D_50);

   use I_100_IO;
   use U_100_IO;
   use D_50_IO;

   type Test_Case_Index is
     (I_100_Range,
      U_100_Range,
      U_100_Wraparound,
      U_100_To_I_100,
      I_100_To_U_100,
      D_50_Range,
      S_50_Range,
      I_100_To_D_50,
      I_100_To_S_50,
      D_50_To_I_100,
      S_50_To_I_100);

   procedure Check (TC : Test_Case_Index) is
   begin
      I_100_IO.Default_Width := 1;
      U_100_IO.Default_Width := 1;
      D_50_IO.Default_Width  := 1;

      case TC is
         when I_100_Range =>
            Put (I_100'First);
            New_Line;
            Put (I_100'Last);
            New_Line;
         when U_100_Range =>
            Put (U_100'First);
            New_Line;
            Put (U_100'Last);
            New_Line;
         when U_100_Wraparound =>
            Put (U_100'First - 1);
            New_Line;
            Put (U_100'Last + 1);
            New_Line;
         when U_100_To_I_100 =>
            for I in U_100'Range loop
               I_100_IO.Put (To_I_100 (I));
               New_Line;
            end loop;
         when I_100_To_U_100 =>
            for I in I_100'Range loop
               Put (To_U_100 (I));
               New_Line;
            end loop;
         when D_50_Range =>
            Put (D_50'First);
            New_Line;
            Put (D_50'Last);
            New_Line;
         when S_50_Range =>
            Put (S_50'First);
            New_Line;
            Put (S_50'Last);
            New_Line;
         when I_100_To_D_50 =>
            for I in I_100'Range loop
               Put (To_D_50 (I));
               New_Line;
            end loop;
         when I_100_To_S_50 =>
            for I in I_100'Range loop
               Put (To_S_50 (I));
               New_Line;
            end loop;
         when D_50_To_I_100 =>
            for I in D_50'Range loop
               Put (To_I_100 (I));
               New_Line;
            end loop;
         when S_50_To_I_100 =>
            for I in S_50'Range loop
               Put (I);
               New_Line;
            end loop;
      end case;
   end Check;

begin
   if Argument_Count < 1 then
      Put_Line ("ERROR: missing arguments! Exiting...");
      return;
   elsif Argument_Count > 1 then
      Put_Line ("Ignoring additional arguments...");
   end if;

   Check (Test_Case_Index'Value (Argument (1)));
end Main;
    
    

        
            int_types.ads
        
            int_types.adb
        
            main.adb
        
    
    

    

        

            
                
                Settings
            
            

                
                    
                    Enable tabbed editor view for this editor
                
                
                    
                    Use the dark theme
                
            
        
        
            
            Reset
        
        
            
            Download
        
    
    

        

            
                Submit
            
        
        

            

            
                

            
        
    

Temperatures

Goal: create a package to handle temperatures in Celsius and Kelvin.

Steps:

1. Implement the Temperature_Types package.

   1. Declare the Celsius type.

   2. Declare the Int_Celsius type.

   3. Implement the To_Celsius function.

   4. Implement the To_Int_Celsius function.

   5. Declare the Kelvin type.

   6. Implement the To_Celsius function to convert from the Kelvin type.

   7. Implement the To_Kelvin function.

Requirements:

1. The custom floating-point types declared in Temperature_Types must use a precision of six digits.

2. Types Celsius and Int_Celsius are used for temperatures in Celsius:

   1. Celsius is a floating-point type with a range between -273.15 and 5504.85.

   2. Int_Celsius is an integer type with a range between -273 and 5505.

3. Functions To_Celsius and To_Int_Celsius are used for type conversion:

   1. To_Celsius converts from Int_Celsius to Celsius type.

   2. To_Int_Celsius converts from Celsius and Int_Celsius types:

4. Kelvin is a floating-point type for temperatures in Kelvin using a range between 0.0 and 5778.0.

5. The functions To_Celsius and To_Kelvin are used to convert between temperatures in Kelvin and Celsius.

   1. In order to convert temperatures in Celsius to Kelvin, you must use the formula \(K = C + 273.15\), where:

      • K is the temperature in Kelvin, and

      • C is the temperature in Celsius.

Remarks:

1. When implementing the To_Celsius function for the Int_Celsius type:

   1. You'll need to check for the minimum and maximum values of the input values because of the slightly different ranges.

   2. You may use variables of floating-point type (Float) for intermediate values.

2. For the implementation of the functions To_Celsius and To_Kelvin (used for converting between Kelvin and Celsius), you may use a variable of floating-point type (Float) for intermediate values.

    
        
in 0:Celsius_Range
out 0:-2.73150E+02 5.50485E+03
in 1:Celsius_To_Int_Celsius
out 1:-273 0 5505
in 2:Int_Celsius_To_Celsius
out 2:-2.73000E+02 0.00000E+00 5.50485E+03
in 3:Kelvin_To_Celsius
out 3:-2.73150E+02 0.00000E+00 5.50485E+03
in 4:Celsius_To_Kelvin
out 4:0.00000E+00 5.77800E+03
    
    
    
        
package Temperature_Types is

   --  Include type declaration for Celsius!
   --
   --  Celsius is [...];
       --  Int_Celsius is [...];
   --

   function To_Celsius (T : Int_Celsius) return Celsius;

   function To_Int_Celsius (T : Celsius) return Int_Celsius;

   --  Include type declaration for Kelvin!
   --
   --  type Kelvin is [...];
   --

   --  Include function declarations for:
   --  - Kelvin  => Celsius
   --  - Celsius => Kelvin
   --
   --  function To_Celsius [...];
   --  function To_Kelvin  [...];
   --
end Temperature_Types;
    
        
package body Temperature_Types is

   function To_Celsius (T : Int_Celsius) return Celsius is
   begin
      null;
   end To_Celsius;

   function To_Int_Celsius (T : Celsius) return Int_Celsius is
   begin
      null;
   end To_Int_Celsius;

   --  Include function implementation for:
   --  - Kelvin  => Celsius
   --  - Celsius => Kelvin
   --
   --  function To_Celsius [...] is
   --  function To_Kelvin  [...] is
   --
end Temperature_Types;
    
        
with Ada.Command_Line;  use Ada.Command_Line;
with Ada.Text_IO;       use Ada.Text_IO;

with Temperature_Types; use Temperature_Types;

procedure Main is
   package Celsius_IO     is new Ada.Text_IO.Float_IO (Celsius);
   package Kelvin_IO      is new Ada.Text_IO.Float_IO (Kelvin);
   package Int_Celsius_IO is new Ada.Text_IO.Integer_IO (Int_Celsius);

   use Celsius_IO;
   use Kelvin_IO;
   use Int_Celsius_IO;

   type Test_Case_Index is
     (Celsius_Range,
      Celsius_To_Int_Celsius,
      Int_Celsius_To_Celsius,
      Kelvin_To_Celsius,
      Celsius_To_Kelvin);

   procedure Check (TC : Test_Case_Index) is
   begin
      Celsius_IO.Default_Fore := 1;
      Kelvin_IO.Default_Fore  := 1;
      Int_Celsius_IO.Default_Width := 1;

      case TC is
         when Celsius_Range =>
            Put (Celsius'First);
            New_Line;
            Put (Celsius'Last);
            New_Line;
         when Celsius_To_Int_Celsius =>
            Put (To_Int_Celsius (Celsius'First));
            New_Line;
            Put (To_Int_Celsius (0.0));
            New_Line;
            Put (To_Int_Celsius (Celsius'Last));
            New_Line;
         when Int_Celsius_To_Celsius =>
            Put (To_Celsius (Int_Celsius'First));
            New_Line;
            Put (To_Celsius (0));
            New_Line;
            Put (To_Celsius (Int_Celsius'Last));
            New_Line;
         when Kelvin_To_Celsius =>
            Put (To_Celsius (Kelvin'First));
            New_Line;
            Put (To_Celsius (0));
            New_Line;
            Put (To_Celsius (Kelvin'Last));
            New_Line;
         when Celsius_To_Kelvin =>
            Put (To_Kelvin (Celsius'First));
            New_Line;
            Put (To_Kelvin (Celsius'Last));
            New_Line;
      end case;
   end Check;

begin
   if Argument_Count < 1 then
      Put_Line ("ERROR: missing arguments! Exiting...");
      return;
   elsif Argument_Count > 1 then
      Put_Line ("Ignoring additional arguments...");
   end if;

   Check (Test_Case_Index'Value (Argument (1)));
end Main;
    
    

        
            temperature_types.ads
        
            temperature_types.adb
        
            main.adb
        
    
    

    

        

            
                
                Settings
            
            

                
                    
                    Enable tabbed editor view for this editor
                
                
                    
                    Use the dark theme
                
            
        
        
            
            Reset
        
        
            
            Download
        
    
    

        

            
                Submit