This Ada program calculates the factorial of a non-negative integer using an iterative approach. The `Calculate_Factorial` function handles the base cases for 0 and 1, and then iteratively multiplies numbers from 2 up to...

The `Calculate_Factorial` function computes the factorial of a given non-negative integer `N`. It initializes a `Long_Integer` variable `Result` to 1. The function first checks for the base cases: if `N` is 0 or 1, it directly returns 1, as the factorial of both is 1. For `N` greater than 1, it enters a loop that iterates from 2 up to `N`. In each iteration, it multiplies the current `Result` by the loop counter `I`. This process continues until all numbers from 2 to `N` have been multiplied into `Result`. The time complexity is O(N) because the loop runs `N-1` times. The space complexity is O(1) as it uses a fixed amount of extra space for variables regardless of the input size. The use of `Long_Integer` helps mitigate overflow for moderately large inputs, though extremely large inputs could still exceed its capacity.

FUNCTION Calculate_Factorial(N): IF N = 0 OR N = 1 THEN RETURN 1 END IF RESULT = 1 FOR I FROM 2 TO N: RESULT = RESULT * I END FOR RETURN RESULT END FUNCTION

This Ada program demonstrates how to reverse a string using a helper procedure for swapping characters. The `Reverse_String` procedure iterates through the first half of the string, swapping each character with its corre...

The `String_Reversal` procedure reverses an `Unbounded_String` in place. It utilizes a helper procedure `Swap_Chars` to exchange characters at specified indices. The main `Reverse_String` procedure calculates the length and midpoint of the string. It then iterates from the first character up to the midpoint, calling `Swap_Chars` to swap the character at index `I` with the character at index `Len - I + 1`. This ensures that characters from the beginning are swapped with their counterparts from the end, effectively reversing the string. The time complexity is O(N), where N is the length of the string, because each character is involved in at most one swap. The space complexity is O(1) as it modifies the string in place without using significant extra memory. Edge cases like empty strings or single-character strings are handled by returning early, as no reversal is needed.

PROCEDURE Reverse_String(S): LEN = length of S IF LEN <= 1 THEN RETURN END IF MID = LEN / 2 FOR I FROM 1 TO MID: SWAP_CHARS(S, I, LEN - I + 1) END FOR END PROCEDURE PROCEDURE Swap_Chars(S, Index1, Index2): IF Index1 and...

This Ada code implements a deterministic finite state machine (FSM) that transitions between states based on incoming events. It defines states like `State_Idle`, `State_Active`, and `State_Error`, and events such as `Ev...

The `State_Machine_Pkg` defines an FSM with three states (`State_Idle`, `State_Active`, `State_Error`) and four events (`Event_Start`, `Event_Stop`, `Event_Reset`, `Event_Fault`). The `Process_Event` procedure uses nested `case` statements to implement the state transition logic. The outer `case` selects transitions based on the `Current_State`, and the inner `case` selects based on the `Input_Event`. For each state-event combination, it either transitions to a new state, stays in the current state, or ignores the event. The `State_To_String` and `Event_To_String` functions are helpers for logging. This FSM is deterministic because for any given state and event, there is exactly one defined next state. The time complexity of `Process_Event` is O(1) as it involves a fixed number of comparisons and assignments, regardless of the number of states or events. Space complexity is also O(1) as it only uses a few variables to track the current state and event.

PACKAGE State_Machine_Pkg IS TYPE State_Type IS (State_Idle, State_Active, State_Error); TYPE Event_Type IS (Event_Start, Event_Stop, Event_Reset, Event_Fault); PROCEDURE Process_Event(Current_State : in out State_Type;...

This Ada code implements robust error handling for safety-critical applications. It defines custom exceptions (`Sensor_Error`, `Processing_Error`) and uses standard Ada exceptions (`Overflow_Error`, `Division_By_Zero`)....

The `Safety_Critical_Pkg` demonstrates advanced exception handling in Ada. It defines custom exceptions `Sensor_Error` and `Processing_Error` alongside standard ones like `Overflow_Error` and `Division_By_Zero`. The `Read_Sensor` function simulates data acquisition. `Process_Sensor_Data` is the core procedure where simulated error conditions (`Simulate_Range_Error`, `Simulate_Overflow_Error`, `Simulate_Division_By_Zero`) are triggered. The `exception` block in `Process_Sensor_Data` catches these specific exceptions and calls `Handle_Error` with a descriptive message. The `others` clause catches any unhandled exceptions. Crucially, `Finalize_Operation` is designed to be called regardless of whether an exception occurred, typically via a `raise` statement within the `exception` block or by ensuring it's called after the `exception` block completes normally. The time complexity of `Process_Sensor_Data` is O(1) in the normal execution path. In the presence of exceptions, the cost includes the exception propagation and handling, which is typically efficient but can be higher than normal execution. Space complexity is O(1). The correctness argument relies on the Ada runtime's guaranteed exception propagation and handling mechanism, ensuring that `Handle_Error` is invoked for specific errors and `Finalize_Operation` is always executed.

PACKAGE Safety_Critical_Pkg IS TYPE Sensor_Error IS new Ada.Exceptions.Exception_Occurrence; TYPE Processing_Error IS new Ada.Exceptions.Exception_Occurrence; TYPE Sensor_Reading_Type IS Float; FUNCTION Read_Sensor RETUR...

This Ada code defines a protected object that provides thread-safe access to a shared integer variable. It includes procedures to write a new value and read the current value. This pattern is crucial for managing shared...

The `Shared_Data_Protected` package defines a protected object `Shared_Data_Type`. Protected objects in Ada provide a mechanism for safe concurrent access to shared data. The `Write_Value` procedure modifies the `Internal_Value`, and `Read_Value` retrieves it. Ada's runtime ensures that only one task can access the protected object's entries (procedures or functions) at a time, preventing data corruption. The `Write_Value` procedure includes a basic validation to ensure the `New_Value` is within a specified range, demonstrating a common safety check. The `Perform_Complex_Calculation` is a helper function to illustrate that protected objects can encapsulate more than just simple data access, though its result isn't directly used in the protected object's logic here. The time complexity for both `Read_Value` and `Write_Value` is O(1) because they involve direct memory access and minimal computation. Space complexity is also O(1) as it only uses a single integer variable.

PACKAGE Shared_Data_Protected IS TYPE Shared_Data_Type IS PROTECTED PROCEDURE Write_Value(New_Value : in Integer); FUNCTION Read_Value RETURN Integer; PRIVATE Internal_Value : Integer := 0; END Shared_Data_Type; END Shar...

This Ada code demonstrates how to manage task priorities in a real-time system. It defines a `Prioritized_Task` type with entries to set and get its priority. The `Task_Scheduler_Pkg` manages a collection of these tasks,...

The `Task_Scheduler_Pkg` provides functionality to manage tasks with dynamic priorities. The `Prioritized_Task` type has `Set_Priority` and `Get_Priority` entries. The `Task_Record` stores task IDs, names, and their current priorities. `Create_Task` initializes a new task and its record. `Update_Task_Priority` calls the task's `Set_Priority` entry and updates the internal record. `Get_Task_Priority` calls the task's `Get_Priority` entry. The `Find_Task` helper efficiently locates a task by its identity. The `Run_Scheduler` procedure simulates the scheduler's role by triggering task execution. The `select` statement within `Prioritized_Task` allows it to respond to entry calls or execute its `Execute` entry. The `delay` statement simulates work. The time complexity for `Set_Priority` and `Get_Priority` operations, including the internal lookup and the task entry call, is roughly O(N) in the worst case, where N is the number of managed tasks, due to the `Find_Task` linear search. However, the actual scheduler's priority management is typically O(1) or O(log N) depending on the underlying OS scheduler implementation. Space complexity is O(M) where M is `Max_Tasks`, for storing task records.

PACKAGE Task_Scheduler_Pkg IS Max_Tasks : constant := 10; TASK TYPE Prioritized_Task (Task_Name : String) IS ENTRY Set_Priority(New_Priority : Priority); ENTRY Get_Priority(Priority_Value : out Priority); ENTRY Execute;...

This Ada code implements a classic producer-consumer problem using a bounded buffer. The `Bounded_Buffer_Pkg` defines a fixed-size buffer and `Put`/`Get` procedures to add and remove items, respectively. It uses Ada's ta...

The `Bounded_Buffer_Pkg` implements a bounded buffer using `Ada.Queues` and condition variables. The `Put` procedure waits if the buffer is full and signals when an item is added. The `Get` procedure waits if the buffer is empty and signals when an item is removed. `Is_Full` and `Is_Empty` are helper functions to check buffer status. The `Producer_Task` generates items and calls `Put`, while the `Consumer_Task` calls `Get` to process them. The use of condition variables (`Not_Full`, `Not_Empty`) ensures that tasks block efficiently when the buffer is in an undesirable state, preventing busy-waiting. The time complexity for `Put` and `Get` is O(1) on average, as enqueue/dequeue operations are constant time. In the worst case, if a task has to wait, the effective time includes the waiting period. Space complexity is O(N) where N is `Buffer_Size`, for storing the buffer elements.

PACKAGE Bounded_Buffer_Pkg IS Buffer_Size : constant := 5; TYPE Buffer_Element_Type IS Integer; TYPE Bounded_Buffer_Type IS new Ada.Queues.Queue; PROCEDURE Put(Buffer : in out Bounded_Buffer_Type; Item : in Buffer_Elemen...