More About Types¶
Aggregate Initialization¶
In this exercise, we'll look into aggregates to initialize records and arrays. Your goal is to:
Create a record type
Recwith four components ofIntegertype and specify default values for them, as indicated by this list:W= 10X= 11Y= 12Z= 13
Create an array type
Int_ArrofIntegerwith 20 elements (ranging from 1 to 20).Implement the procedure
Initthat outputs a recordRec, whereXis initialized with 100,Yis initialized with 200, and the remaining elements use their default values.Implement the procedure
Init_Somethat outputs an arrayInt_Arrwhere the first five elements are initialized with the value 99, and the remaining elements are initialized with the value 100.Implement the procedure
Initthat outputs an arrayInt_Arrwhere all elements are initialized with the value 5.
Versioning¶
In this exercise, you'll implement a simple package for source-code versioning. This requires the use of function overloading. Your goal is to:
- Declare a record type
Versionwith the componentsMajor,MinorandMaintenanceofNaturaltype. - Implement a function
Convertthat returns a string containing the version number.- Hint: you can make use of the
Image_Trimfunction, as indicated in the source-code below (see package body ofVersioning)
- Hint: you can make use of the
- Implement a function
Convertthat returns a floating-point number, where the number before the decimal point corresponds to the major number and the number after the decimal point corresponds to the minor number.- For example, version "1.3.5" is converted to the floating-point number
1.3.
- For example, version "1.3.5" is converted to the floating-point number
Simple todo list¶
In this exercise, you'll implement a simple to-do list system. In order to do that, you'll use access types and unconstrained arrays. This is the system specification:
Todo_Itemtype: this is used to store to-do items. It should be implemented as an access type to strings.Todo_Listtype: it's the container for all to-do items. It should be implemented as an unconstrained array with positive range.- Hint: don't forget to keep track of the last element added to the list!
Addprocedure: it's used to add items (ofTodo_Itemtype) to the list (ofTodo_Listtype).- Hint: this requires allocating a string for the access type.
Displayprocedure: it's used to display all to-do items. It must display one item per line.
Price list¶
In this exercise, you'll implement a list containing prices. In order to accomplish this, you'll use the following features of the Ada language:
- decimal fixed-point types;
- records with discriminants;
- dynamically-sized record types;
- variant records.
Your goals are:
Declare a decimal fixed-point data type
Price_Typewith a delta of two digits (e.g.0.01) and twelve digits in total.Declare the record type
Price_Listthat contains the price list. This record type must have a discriminant for the maximum number of elements of the list.- Hint: you may use an unconstrained array as a component of the record and use the discriminant in the component declaration.
Implement the procedure
Resetto reset the list.Implement the procedure
Addto add a price to the list.- Hint: you should keep track of the last element added to the list.
Implement the
Getfunction to retrieve a price from the list using an index. This function returns a record instance of typePrice_Result:Price_Resultis a variant record containing the Boolean componentOkand the componentPrice(ofPrice_Type).- If the index specified in a call to
Getcontains a valid (initialized) price,Okis set toTrueandPricecontains the price for that index. Otherwise,Okis set toFalseand thePricecomponent is not available.
Implement the procedure
Displayto show all prices from the list. The header (first line) must bePRICE LIST, while the remaining lines contain one price per line.
For example, for the following code:
procedure Test is
L : Price_List (10);
begin
Reset (L);
Add (L, 1.45);
Add (L, 2.37);
Display (L);
end Test;
The output is:
PRICE LIST
1.45
2.37
Binary fixed-point types¶
In this exercise, you'll work on a square-root calculation algorithm implemented with fixed-point data types. The original algorithm was implemented in C language by Christophe Meessen and was taken from this repository on Github. This is the original source-code of the function that we want to port to Ada and use in our test application:
typedef int32_t fixed;
/*
* fixed sqrtF2F( fixed v );
*
* Compute fixed to fixed square root
* RETURNS the fixed point square root of v (fixed)
* REQUIRES v is positive
*/
fixed sqrtF2F ( fixed x )
{
uint32_t t, q, b, r;
r = x;
b = 0x40000000;
q = 0;
while( b > 0x40 )
{
t = q + b;
if( r >= t )
{
r -= t;
q = t + b; // equivalent to q += 2*b
}
r <<= 1;
b >>= 1;
}
q >>= 8;
return q;
}
In order to complete this exercise, you don't need to worry about the
implementation details of the Sqrt function. If you look at the
body of the Fixed_Point_Ops package in the source-code below,
you'll see that it already contains the ported algorithm! Your only task
in this exercise is to declare the correct fixed-point data type
Fixed — in the specification of the Fixed_Point_Ops
package — for the Sqrt function.
As a bonus, however, if you're looking for a more challenging exercise,
you may adapt the ported algorithm for multiple, arbitrary formats of
fixed-point data types. The implementation of Sqrt shown below only
works fine for Q15.16 — as in the original C code. However, you may
adapt the algorithm to make it work for Q31.32, Q23.24, Q11.12, Q7.6, or
unsigned version such as Q32.32, Q24.24, and Q12.12, or even formats such
as Q7.24. This may require some generalization of the Fixed
declaration as well as the Sqrt function implementation. For
example, you may use a type declaration such as
type Fixed is delta F_Delta range 0.0 .. F_Last - F_Delta; and
declare F_Delta and F_Last with constant values depending on
which Qx.y format you want to use.
Inventory¶
In this exercise, you'll improve the simplified inventory system for your store, which you designed in a previous lab (see Records) The system will be used to enter items and keep track of your assets. These are the improvements that you'll implement:
- Support for storing items on a database, so that you're able to retrieve and display them later.
- Support for storing information about how many units have been bought and sold for each item.
Your goals with this exercise are:
Create a database using arrays and records to store the information. You need to declare the record types
ItemandInventory.- Hint: you can take the same approach as for the previous lab on
Price list for the
Inventorytype.
- Hint: you can take the same approach as for the previous lab on
Price list for the
Declare a decimal fixed-point data type
Amountwith a delta of two digits (e.g.0.01) and twelve digits in total.- Hint: you can reuse the type declaration of the
Price_Typetype from the previous lab on Price list.
- Hint: you can reuse the type declaration of the
Declare
Name_Typeas an access type to strings.- Hint: you can reuse the type declaration of the
Todo_Itemtype from the previous lab on Simple To-Do List.
- Hint: you can reuse the type declaration of the
Declare the variant record type
Add_Statuswith a Boolean type as a discriminant. This type is used for an output parameter of theAddprocedure, which we'll discuss later.- Hint: as a starting point, you can reuse the declaration of the
Price_Resulttype from the previous lab on Price list.
- Hint: as a starting point, you can reuse the declaration of the
Implement two
Initfunctions: one for theItemtype and one for theInventorytype. Make sure to initialize all relevant components!Implement the
Addprocedure for adding items to your inventory. As mentioned above, this procedure has an output parameter ofAdd_Statustype:- If the call to
Addis successful,Successis set toTrueandIDcontains the index of the item that has just been added. Otherwise,Successis set toFalseand theIDcomponent is not available.
- If the call to
Implement the
Last_Idfunction, which returns the index of the last item of the list.Implement the
Setprocedure for adding transaction information (bought or sold units) for a specific item from the inventory.- This procedure has the output parameter
Successof Boolean type, which indicates whether the call was successful or not. This happens, for example, when 20 units are available for an item, and the call to theSetprocedure attemps to sell 30 units, which could lead to a negative number of items. In this case, the call toSetindicates a failure. For example:
Add (Inv, Init ("Chair", 200.00), Status); if Status.Success then Set (Inv => Inv, Trans => Bought, ID => Status.ID, Quantity => 20, Success => Success); -- Success = False in the call below, because we only have -- 20 units in stock, so we cannot sell 30 units. Set (Inv => Inv, Trans => Sold, ID => Status.ID, Quantity => 30, Success => Success); end if;
- This procedure has the output parameter
Implement the following
Getfunctions:function Get (Inv : Inventory; ID : Item_ID) return String; -- Retrieve item name function Get (Inv : Inventory; ID : Item_ID) return Item_Quantity; -- Retrieve number of units in stock for specified item function Get (Inv : Inventory; ID : Item_ID) return Amount; -- Retrieve total amount in stock for specified item function Get (Inv : Inventory; Trans : Transaction_Type; ID : Item_ID) return Item_Quantity; -- Retrieve number of units for specified item and transaction type function Get (Inv : Inventory; Trans : Transaction_Type; ID : Item_ID) return Amount; -- Retrieve amount for specified item and transaction type function Get (Inv : Inventory; Trans : Transaction_Type) return Amount; -- Retrieve amount for transaction type function Get (Inv : Inventory) return Amount; -- Retrieve amount for whole inventory
- Note that overloading is used for most of these functions. Therefore, the actual function called for a specific variable depends on its type (as indicated in the comments of the code block above). For example:
procedure Test is Inv : Inventory (3); begin -- -- Add two items to the database -- declare Success : Boolean; Status : Add_Status; begin Add (Inv, Init ("Chair", 200.0), Status); Set (Inv, Bought, Status.ID, 10, Success); Set (Inv, Sold, Status.ID, 5, Success); Add (Inv, Init ("Table", 300.0), Status); Set (Inv, Bought, Status.ID, 20, Success); Set (Inv, Sold, Status.ID, 10, Success); end; -- -- Retrieve information from the database -- declare ID : Item_ID := Get (Inv, "Chair"); Item_Name : String := Get (Inv, ID); Number_Units_In_Stock_For_Item : Item_Quantity := Get (Inv, ID); Potential_Income_For_Units_In_Stock_For_Item : Amount := Get (Inv, ID); Number_Units_Sold_For_Item : Item_Quantity := Get (Inv, Sold, ID); Income_For_Sold_Units_Of_Item : Amount := Get (Inv, Sold, ID); Income_For_All_Sold_Units : Amount := Get (Inv, Sold); Potential_Income_For_All_Units_In_Stock : Amount := Get (Inv); begin -- Some processing here... null; end; end Test;
- Remark: we didn't mention error handling for the
IDparameter of theGetfunctions above — as we had in a previous exercise (see Price list). If theIDindicates an item that hasn't been initialized yet, the information returned by theGetfunction is essentially garbage. Although this is an important check to make, we're leaving it out of this specification to simplify the exercise a little bit. You may, however, as a bonus for this exercise, extend the system to cover this check.
As you've probably noticed, this exercise consists of many steps, so it takes more time to complete it than it took for previous labs. However, as indicated in the description above, you may reuse many elements that you already implemented in previous labs. This may make it quicker to finish the implementation work of this exercise.