with Text_IO;             use Text_IO;
with Translate;           use Translate;
with unbounded_strings;   use unbounded_strings;
with Scheduler;           use Scheduler;
with Scheduling_Analysis; use Scheduling_Analysis;
use Scheduling_Analysis.Double_Tasks_Parameters_Package;
with Tasks;                             use Tasks;
use Tasks.Generic_Task_List_Package;
with Task_Set;                          use Task_Set;
with Offsets;               use Offsets;
with Offsets.extended;      use Offsets.extended;
with Task_Dependencies;   use Task_Dependencies;
with Dependencies;        use Dependencies;

package body Feasibility_Test.generated_R2 is

procedure compute_less_equal 
(My_Tasks      : in Tasks_Set;
Processor_Name : in Unbounded_String;
Current_Task : in Generic_Task_Ptr;
Value_W_i : out MY_ARRAY;
q: out integer)
is
  My_Iterator : Tasks_Iterator;
  Taski    : Generic_Task_Ptr; 
  rightvalue  : Double; 
  leftvalue : Double;
  k: integer:=0;
begin 
reset_iterator (My_Tasks, My_Iterator);
current_element (My_Tasks, Taski, My_Iterator);
rightvalue := 0.0;
leftvalue :=0.0; 
Value_W_i(0):=1.0;
While (Value_W_i(k) >=  rightvalue)  loop     
  leftvalue :=Double(W_i(My_Tasks,Double(k),Taski)) ; 							 
  rightvalue :=Double(Periodic_Task_Ptr(Taski).period)*Double(1.0+Double(k));    
  Value_W_i(k):= leftvalue;
  k:=k+1;
end loop;
q:=k;
end compute_less_equal;

function W_i				 
(My_Tasks     : in Tasks_Set;
q:in Double;
Current_Task : in Generic_Task_Ptr
)
return     Double
is
Iterator : Tasks_Iterator;
Taski, Taskj    : Generic_Task_Ptr;
calcul, tmp   : Double;
begin
calcul := 0.0;
tmp:=-0.1;
current_element (My_Tasks, Taski, Iterator);
While (tmp/=calcul)  loop
 reset_iterator (My_Tasks, Iterator);
 tmp :=calcul;
  calcul :=  (Double(Current_Task.capacity))*(1.0+q);
   loop
     current_element (My_Tasks, Taskj, Iterator);
     if (Taskj.priority > Current_Task.priority) then
       calcul := calcul + double((Double(Taskj.capacity))*(Double'Ceiling((Double(Periodic_Task_Ptr (Taskj).jitter)+tmp)/(Double(Periodic_Task_Ptr (Taskj).period)))));
      end if;
    exit when is_last_element (My_Tasks, Iterator);
    next_element (My_Tasks, Iterator);
   end loop;
end loop; 
return calcul;
end W_i;

function max_r_i
(My_Tasks     : in Tasks_Set;
W_i           : in MY_ARRAY;
nb_value_W_i  : in integer;
Current_Task  : in Generic_Task_Ptr
)
return  Double
is
My_Iterator : Tasks_Iterator;
Taski    : Generic_Task_Ptr;       
q : integer;
calcul,max : Double;
begin
  calcul := 0.0;
  current_element (My_Tasks, Taski, My_Iterator);
  max :=0.0;
  for q in 0..nb_value_W_i loop
    calcul := Double(Periodic_Task_Ptr(Taski).jitter)+Double(Periodic_Task_Ptr(Taski).blocking_time) + W_i(q)-Double(q)*Double(Periodic_Task_Ptr(Taski).period);
  if calcul > max then
   max:=calcul;
  end if;
end loop;
return max;
end max_r_i;

end Feasibility_Test.generated_R2;