SCHEMA Systems;
	USE FROM Tasks;
	USE FROM Resources;
	USE FROM Core_Units;
	USE FROM Processors;
	USE FROM express_toolsbox_functions;

	ENTITY System;
		Tasks : LIST OF Generic_Task;
		Resources : LIST OF Generic_Resource;
		Core_units : LIST OF Core_Unit;
		Processors : LIST OF Generic_Processor;
	END_ENTITY;

	PROCEDURE Print_System ( s : System );

		REPEAT no := LOINDEX ( s.Tasks ) TO HIINDEX ( s.Tasks );
			ALIAS t FOR s.Tasks [ no];
				PrintLn ( s );
			END_ALIAS;
		END_REPEAT;
	END_PROCEDURE;

	FUNCTION all_Systems : LIST OF System;
		LOCAL 
			insts : SET OF GENERIC := allModelInstances;
		END_LOCAL;
		RETURN ( QUERY ( i <* insts | 'SYSTEMS.SYSTEM' IN TYPEOF ( i ) ) );
	END_FUNCTION;

	PROCEDURE Print_All_Systems;
		LOCAL 
			insts : LIST OF System := all_Systems;
		END_LOCAL;

		REPEAT no := LOINDEX ( insts ) TO HIINDEX ( insts );
			ALIAS s FOR insts [ no];
				Print_System ( s );
			END_ALIAS;
		END_REPEAT;
	END_PROCEDURE;
END_SCHEMA;

SCHEMA Cheddar_Symbolic_Expressions;
	USE FROM express_toolsbox_functions;

	TYPE Symb_Operator_Type = ENUMERATION
		OF ( Plus_Type,
			 Minus_Type,
			 Divide_Type,
			 Multiplya_Type,
			 Sum_Type,
			 Pi_Type,
			 Ceil_Type,
			 Floor_type,
			 Min_Type,
			 Max_type );
	END_TYPE;

	TYPE Symb_Logic_Type = ENUMERATION
		OF ( Equal_Less_Type, Less_Type );
	END_TYPE;

	TYPE Symb_Element_Array_Type = ENUMERATION
		OF ( C_i, P_i, B_i, B_j, J_i, J_j, C_j, P_j );
	END_TYPE;

	ENTITY Generic_Symb_Logic_Expression 
		ABSTRACT SUPERTYPE;
		operator_type : Symb_Logic_Type;
		rvalue : Generic_Symb_Expression;
		lvalue : Generic_Symb_Expression;
	DERIVE
		code_latex : STRING := Generic_Symb_Expression_Code_Latex ( SELF );
	END_ENTITY;

	ENTITY Generic_Symb_Expression 
		ABSTRACT SUPERTYPE;
		operator_type : Symb_Operator_Type;
	DERIVE
		code_latex : STRING := Generic_Symb_Expression_Code_Latex ( SELF );
		code_ada : STRING := Generic_Symb_Expression_Code_Ada ( SELF );
		code_ada_WCRT : STRING := Generic_Symb_Expression_Code_Ada_WCRT ( SELF );
	END_ENTITY;

	FUNCTION Generic_Symb_Expression_Code_Latex ( EXP : Generic_Symb_Expression ) : STRING;
		RETURN ( '????' );
	END_FUNCTION;

	FUNCTION Generic_Symb_Expression_Code_Ada ( EXP : Generic_Symb_Expression ) : STRING;
		RETURN ( '????' );
	END_FUNCTION;

	FUNCTION Generic_Symb_Expression_Code_Ada_WCRT ( EXP : Generic_Symb_Expression ) : STRING;
		RETURN ( '????' );
	END_FUNCTION;

	(*an integer*)
	ENTITY An_Integer_Expression 
		SUBTYPE OF ( Generic_Symb_Expression );
		An_Element : STRING;
	DERIVE
		SELF\Generic_Symb_Expression.code_latex : STRING := An_Element;
		SELF\Generic_Symb_Expression.code_ada : STRING := An_Element;
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := An_Element;
	END_ENTITY;

	(*C_i*)
	ENTITY An_Element_Array_Expression 
		SUBTYPE OF ( Generic_Symb_Expression );
		Index : STRING;
		Element : Symb_Element_Array_Type;
	DERIVE
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Element_Array_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Element_Array_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Element_Array_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Element_Array_Expression_code_latex ( EXP : An_Element_Array_Expression ) : STRING;

		IF ( EXISTS ( EXP.Element ) ) THEN
			IF ( EXP.Element = C_i ) THEN
				RETURN ( 'C_i' );
			ELSE
				IF ( EXP.Element = P_i ) THEN
					RETURN ( 'P_i' );
				ELSE
					IF ( EXP.Element = P_j ) THEN
						RETURN ( 'P_j' );
					ELSE
						IF ( EXP.Element = C_j ) THEN
							RETURN ( 'C_j' );
						ELSE
							IF ( EXP.Element = B_i ) THEN
								RETURN ( 'B_i' );
							ELSE
								RETURN ( 'J_i' );
							END_IF;
						END_IF;
					END_IF;
				END_IF;
			END_IF;
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Element_Array_Expression_code_ada ( EXP : An_Element_Array_Expression ) : STRING;

		IF ( EXP.Element = C_i ) THEN
			RETURN ( 'Current_Task.capacity' );
		ELSE
			IF ( EXP.Element = P_i ) THEN
				RETURN ( 'Current_Task.period' );
			ELSE
				IF ( EXP.Element = P_j ) THEN
					RETURN ( 'Double(Periodic_Task_Ptr (Taskj).period)' );
				ELSE
					IF ( EXP.Element = C_j ) THEN
						RETURN ( 'Double(Taskj.capacity)' );
					ELSE
						IF ( EXP.Element = B_i ) THEN
							RETURN ( 'Current_Task.blocking_time' );
						ELSE
							IF ( EXP.Element = J_i ) THEN
								RETURN ( 'Current_Task.jitter' );
							ELSE
								IF ( EXP.Element = B_j ) THEN
									RETURN ( 'Double(Periodic_Task_Ptr (Taskj).blocking_time)' );
								ELSE
									RETURN ( 'Double(Periodic_Task_Ptr (Taskj).jitter)' );
								END_IF;
							END_IF;
						END_IF;
					END_IF;
				END_IF;
			END_IF;
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Element_Array_WCRT_Expression_code_ada ( EXP : An_Element_Array_Expression ) : STRING;

		IF ( EXP.Element = C_i ) THEN
			RETURN ( 'Double(Current_Task.capacity)' );
		ELSE
			IF ( EXP.Element = P_i ) THEN
				RETURN ( 'Double(Current_Task.period)' );
			ELSE
				IF ( EXP.Element = P_j ) THEN
					RETURN ( 'Double(Periodic_Task_Ptr (Taskj).period)' );
				ELSE
					IF ( EXP.Element = C_j ) THEN
						RETURN ( 'Double(Taskj.capacity)' );
					ELSE
						IF ( EXP.Element = B_i ) THEN
							RETURN ( 'Current_Task.blocking_time' );
						ELSE
							IF ( EXP.Element = J_i ) THEN
								RETURN ( 'Current_Task.jitter' );
							ELSE
								IF ( EXP.Element = B_j ) THEN
									RETURN ( 'Double(Periodic_Task_Ptr (Taskj).blocking_time)' );
								ELSE
									RETURN ( 'Double(Periodic_Task_Ptr (Taskj).jitter)' );
								END_IF;
							END_IF;
						END_IF;
					END_IF;
				END_IF;
			END_IF;
		END_IF;
	END_FUNCTION;

	ENTITY Symb_Unary_Expression 
		SUBTYPE OF ( Generic_Symb_Expression );
		VALUE : Generic_Symb_Expression;
		operator : Symb_Operator_Type;
	END_ENTITY;

	ENTITY Symb_Binary_Expression 
		SUBTYPE OF ( Generic_Symb_Expression );
		rvalue : Generic_Symb_Expression;
		lvalue : Generic_Symb_Expression;
	END_ENTITY;

	ENTITY Symb_Multiary_Expression 
		SUBTYPE OF ( Generic_Symb_Expression );
		index : STRING;
		lower_bound : STRING;
		formula : Generic_Symb_Expression;
		symb_expression : Symb_Operator_Type;
	END_ENTITY;

	(*min*)
	ENTITY Symb_Min_Expression 
		SUBTYPE OF ( Symb_Multiary_Expression );
		upper_bound : Generic_Symb_Expression;
	DERIVE
		SELF\Generic_Symb_Expression.operator_type : Symb_Operator_Type := Min_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Min_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Min_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Min_Expression_code_ada_WCRT ( SELF );
	END_ENTITY;

	FUNCTION Symb_Min_Expression_code_latex ( EXP : Symb_Min_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( 'min_{' +
				 EXP.lower_bound +
				 ' ' +
				 '\\le i \\le ' +
				 EXP.upper_bound.code_latex +
				 '} ' +
				 EXP.formula.code_latex );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Min_Expression_code_ada ( EXP : Symb_Min_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( 'Min(' + EXP.formula.code_ada + ');' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;
	FUNCTION Symb_Min_Expression_code_ada_WCRT( EXP : Symb_Min_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( 'function min_r_i
(My_Tasks     : in Tasks_Set;
W_i           : in MY_ARRAY;
Current_Task  : in Generic_Task_Ptr
)
return  Double
is
Iterator : Tasks_Iterator;
Taski    : Generic_Task_Ptr;       
q,k:integer;
begin
  calcul := 0.0;
  current_element (My_Tasks, Taski, My_Iterator);
  k := w_i"Length;
  min :=0;
  for q in 0..k loop
    calcul :=' + EXP.formula.code_ada+';
  if calcul < min then
   min:=calcul;
  end if;
end loop;
return min;
end min_r_i;' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;


	(*max*)
	ENTITY Symb_Max_Expression 
		SUBTYPE OF ( Symb_Multiary_Expression );
		upper_bound : Generic_Symb_Expression;
	DERIVE
		SELF\Symb_Multiary_Expression.symb_expression : Symb_Operator_Type := Max_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Max_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Max_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Max_Expression_code_ada_WCRT ( SELF );
	END_ENTITY;

	FUNCTION Symb_Max_Expression_code_latex ( EXP : Symb_Max_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( 'max_{' +
				 EXP.lower_bound +
				 ' ' +
				 '\\le i \\le ' +
				 EXP.upper_bound.code_latex +
				 '} ' +
				 EXP.formula.code_latex );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Max_Expression_code_ada ( EXP : Symb_Max_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( 'Max(' + EXP.formula.code_ada + ');' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;
FUNCTION Symb_Max_Expression_code_ada_WCRT ( EXP : Symb_Max_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( 'function max_r_i
(My_Tasks     : in Tasks_Set;
W_i           : in MY_ARRAY;
Current_Task  : in Generic_Task_Ptr
)
return  Double
is
Iterator : Tasks_Iterator;
Taski    : Generic_Task_Ptr;       
q,k:integer;
begin
  calcul := 0.0;
  current_element (My_Tasks, Taski, My_Iterator);
  k := w_i"Length;
  max :=0;
  for q in 0..k loop
    calcul :=' + EXP.formula.code_ada+';
  if calcul > max then
   max:=calcul;
  end if;
end loop;
return max;
end max_r_i;' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	(*sigma of an expression*)
	ENTITY Symb_Sum_Expression 
		SUBTYPE OF ( Symb_Multiary_Expression );
	DERIVE
		SELF\Symb_Multiary_Expression.symb_expression : Symb_Operator_Type := Sum_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Sum_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Sum_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Sum_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Sum_Expression_code_latex ( EXP : Symb_Sum_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( '\\sum_{i=' + EXP.lower_bound + '}^{n}' + EXP.formula.code_latex );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Sum_Expression_code_ada ( EXP : Symb_Sum_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( '
			   function Compute
                         (My_Tasks       : in Tasks_Set;
                          Processor_Name : in Unbounded_String)
                          return           Double
                     is
                     calcul : Double := 0.0;
                     My_Iterator : Tasks_Iterator;
                     A_Task      : Generic_Task_Ptr;

                      begin 
                      Periodic_Control (My_Tasks, Processor_Name);
                      reset_iterator (My_Tasks, My_Iterator);
 
                            ' +
				 '
		           loop
			           current_element (My_Tasks, A_Task, My_Iterator); 
				      if (A_Task.task_type /= Aperiodic_Type) then
				                calcul := calcul + ' +
				 EXP.formula.code_ada +
				 ';
				
				        end if; 
				
				 exit when  is_last_element (My_Tasks, My_Iterator); 
				 next_element (My_Tasks, My_Iterator);
				 end loop; 
				 
				  return calcul ; 
				end compute;' );
		ELSE
			RETURN ( 'error: formula doesnt exit' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Sum_WCRT_Expression_code_ada ( EXP : Symb_Sum_Expression ) : STRING;

		IF ( EXISTS ( EXP.formula ) ) THEN
			RETURN ( '
			
	 function compute
	        (My_Tasks       : in Tasks_Set;
              )
               return           Double 
              is         
			              calcul := 0;
			
			  My_Iterator : Tasks_Iterator;
                    Taskj      : Generic_Task_Ptr;

                    begin
		       
		       While (tmp/=calcul) | (calcul >A_Task.period)  loop
				 	
				reset_iterator (My_Tasks, Iterator);
				 
				tmp :=calcul;          
				 
		            loop
				   current_element (My_Tasks, Taskj, Iterator); 
				 if (Taskj.priority > Current_Task.priority) then' +
				 '
			                        calcul := calcul + ' +
				 EXP.formula.code_ada +
				 '; 
				  end if;
				  exit when is_last_element (My_Tasks, Iterator)
				  next_element (My_Tasks, My_Iterator);
				  end loop;
	           end loop; 
	           return calcul;
	end compute; ' );
		ELSE
			RETURN ( 'error: formula doesnt exit' );
		END_IF;
	END_FUNCTION;

	(*B_i+C_i +sum(formula)*)
	ENTITY Symb_Sum_WCRT_Expression 
		SUBTYPE OF ( Symb_Binary_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Operator_Type := Plus_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Sum_Binary_WCRT_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Sum_Uniary_WCRT_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Sum_Binary_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Sum_Binary_WCRT_Expression_code_latex ( EXP : Symb_Sum_WCRT_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( EXP.lvalue.code_latex + '+' + EXP.rvalue.code_latex );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Sum_Uniary_WCRT_Expression_code_ada ( EXP : Symb_Sum_WCRT_Expression ) : STRING;

		IF ( EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( 'function compute' +
				 '
                                 (My_Tasks     : in Tasks_Set;
                                 Current_Task : in Generic_Task_Ptr)
                                  return         Double;)
                                  is
                                  Iterator : Tasks_Iterator;
                                 Taskj    : Generic_Task_Ptr;
				 
                                  calcul, tmp   : Double;
				 
                        begin
				 
			             calcul := 0;
			             tmp:=0;
				 While (tmp/=calcul) | (calcul >A_Task.period)  loop 
				 reset_iterator (My_Tasks, Iterator);
				 tmp :=calcul; 
			        
				loop
				    current_element (My_Tasks, A_Task, Iterator);
		                if (Taskj.priority > Current_Task.priority) then
				 ' +
				 '
			                 calcul := calcul + ' +
				 EXP.rvalue.code_ada_WCRT +
				 ';' +
				 '
				    end if;
				 exit when is_last_element (My_Tasks, Iterator)
				 next_element (My_Tasks, My_Iterator);
				 end loop;
				 
	            end loop; 	 
	            return calcul;' );
		ELSE
			RETURN ( 'error: formula doesnt exit' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Sum_Binary_WCRT_Expression_code_ada ( EXP : Symb_Sum_WCRT_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND ( EXISTS ( EXP.rvalue ) ) ) THEN
			RETURN ( WriteFile ( 'code_generation.adb',
					 string_replace ( '
		function compute
				 
                 (My_Tasks     : in Tasks_Set;
                 Current_Task : in Generic_Task_Ptr)
                 return         Double	 
                  is
                          Iterator : Tasks_Iterator;
				 
                          Taskj    : Generic_Task_Ptr;
				 
                           calcul, tmp   : Double;
				 
                           begin
				 
			  
			         calcul := 0.0;
		               tmp:=-0.1;
				   While (tmp/=calcul)  loop
			         reset_iterator (My_Tasks, Iterator);
				   tmp :=calcul;
				  ' +
						 ' 
				
				  calcul :=  ' +
						 EXP.lvalue.code_ada_WCRT +
						 ';' +
						 '
				loop
				   current_element (My_Tasks, Taskj, Iterator);
				  if (Taskj.priority > Current_Task.priority) then' +
						 '
			               calcul := calcul + ' +
						 'double(' +
						 EXP.rvalue.code_ada_WCRT +
						 ');
				   end if;
				    exit when is_last_element (My_Tasks, Iterator);
				     next_element (My_Tasks, Iterator);
				 end loop;
	            end loop; 
	         return calcul;
	end compute;',
						 '''''',
						 '''' ) ) );
		ELSE
			RETURN ( 'error: formula doesnt exit' );
		END_IF;
	END_FUNCTION;
(*Union expression*)
ENTITY Symb_Union_Expression 
		SUBTYPE OF ( Symb_Binary_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Operator_Type := Plus_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_S_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_S_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_S_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_S_Expression_code_latex ( EXP : Symb_Plus_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( '\bigcup\limits_{j=1}^n('+EXP.lvalue.code_ada+'0\lek\le'+EXP.rvalue.code_ada);
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_S_Expression_code_ada ( EXP : Symb_Plus_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( 'function compute_S
(My_Tasks       : in Tasks_Set;
Processor_Name : in Unbounded_String)
return           MY_ARRAY
is
  Taski    : Generic_Task_Ptr;
  My_Iterator : Tasks_Iterator;
  calcul : Double := 0.0;
  S: MY_ARRAY;
  i,j,k : integer:=0;
begin
i:='+ EXP.rvalue.code_ada+';
Periodic_Control (My_Tasks, Processor_Name);
reset_iterator (My_Tasks, My_Iterator);

for k in 0 .. i loop    
    loop
	current_element (My_Tasks, Taskj, My_Iterator); 
	if (Taski.task_type /= Aperiodic_Type) then
	S(j):= '+EXP.lvalue.code_ada +';
	j := j+1;
	end if; 
	exit when  is_last_element (My_Tasks, My_Iterator); 
	next_element (My_Tasks, My_Iterator);
    end loop; 
end loop;
return S;
end compute_S;' );
		ELSE
			RETURN ( '****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_S_WCRT_Expression_code_ada ( EXP : Symb_Plus_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( 'function compute_S
(My_Tasks       : in Tasks_Set;
Processor_Name : in Unbounded_String)
return           MY_ARRAY
is
  Taski    : Generic_Task_Ptr;
  My_Iterator : Tasks_Iterator;
  calcul : Double := 0.0;
  S: MY_ARRAY;
  i,j,k:integer:=0;
begin
i:='+ EXP.rvalue.code_ada+';
Periodic_Control (My_Tasks, Processor_Name);
reset_iterator (My_Tasks, My_Iterator);

for k in 0 .. i loop    
    loop
	current_element (My_Tasks, Taskj, My_Iterator); 
	if (Taski.task_type /= Aperiodic_Type) then
	S(j):= '+EXP.lvalue.code_ada +';
	j := j+1;
	end if; 
	exit when  is_last_element (My_Tasks, My_Iterator); 
	next_element (My_Tasks, My_Iterator);
    end loop; 
end loop;
return S;
end compute_S;');
		ELSE
			RETURN ( '****' );
		END_IF;
	END_FUNCTION;

	(*a + b*)
	ENTITY Symb_Plus_Expression 
		SUBTYPE OF ( Symb_Binary_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Operator_Type := Plus_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Plus_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Plus_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Plus_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Plus_Expression_code_latex ( EXP : Symb_Plus_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( EXP.lvalue.code_latex + '+' + EXP.rvalue.code_latex );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Plus_Expression_code_ada ( EXP : Symb_Plus_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( EXP.lvalue.code_ada + '+' + EXP.rvalue.code_ada );
		ELSE
			RETURN ( '****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Plus_WCRT_Expression_code_ada ( EXP : Symb_Plus_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( EXP.lvalue.code_ada_WCRT + '+' + EXP.rvalue.code_ada_WCRT );
		ELSE
			RETURN ( '****' );
		END_IF;
	END_FUNCTION;

	(*a - b*)
	ENTITY Symb_Minus_Expression 
		SUBTYPE OF ( Symb_Binary_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Operator_Type := Minus_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Minus_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Minus_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Minus_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Minus_Expression_code_latex ( EXP : Symb_Minus_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( EXP.lvalue.code_latex + '-' + EXP.rvalue.code_latex );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Minus_Expression_code_ada ( EXP : Symb_Minus_Expression ) : STRING;
		RETURN ( EXP.lvalue.code_ada + '-' + EXP.rvalue.code_ada );
	END_FUNCTION;

	FUNCTION Symb_Minus_WCRT_Expression_code_ada ( EXP : Symb_Minus_Expression ) : STRING;
		RETURN ( EXP.lvalue.code_ada_WCRT + '-' + EXP.rvalue.code_ada_WCRT );
	END_FUNCTION;

	(*a \ b*)
	ENTITY Symb_Divide_Expression 
		SUBTYPE OF ( Symb_Binary_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Operator_Type := Divide_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Divide_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Divide_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Divide_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Divide_Expression_code_latex ( EXP : Symb_Divide_Expression ) : STRING;

		IF ( EXISTS ( EXP.rvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( '\\frac{' + EXP.lvalue.code_latex + '}{' + EXP.rvalue.code_latex + '}' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Divide_Expression_code_ada ( EXP : Symb_Divide_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( '(' + EXP.lvalue.code_ada+')' + '/' +'('+ EXP.rvalue.code_ada + ')' );
		ELSE
			RETURN ( '****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Divide_WCRT_Expression_code_ada ( EXP : Symb_Divide_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( '('+EXP.lvalue.code_ada_WCRT +')'+ '/' +'('+ EXP.rvalue.code_ada_WCRT+')' );
		ELSE
			RETURN ( '****' );
		END_IF;
	END_FUNCTION;

	(*min(a,b)*)
	ENTITY Symb_Min_a_b_Expression 
		SUBTYPE OF ( Symb_Binary_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Operator_Type := Min_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Min_a_b_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Min_a_b_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Min_a_b_Expression_code_latex ( EXP : Symb_Min_a_b_Expression ) : STRING;

		IF ( EXISTS ( EXP.rvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( 'min (' + EXP.lvalue.code_latex + ',' + EXP.rvalue.code_latex + ')' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Min_a_b_Expression_code_ada ( EXP : Symb_Min_a_b_Expression ) : STRING;

		IF ( EXISTS ( EXP.rvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( 'min (' + EXP.lvalue.code_ada + ',' + EXP.rvalue.code_ada + ')' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	(*ceiling operation*)
	ENTITY Symb_Ceil_Expression 
		SUBTYPE OF ( Symb_Unary_Expression );
	DERIVE
		SELF\Symb_Unary_Expression.operator_type : Symb_Operator_Type := Ceil_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Ceil_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Ceil_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Ceil_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Ceil_Expression_code_latex ( EXP : Symb_Ceil_Expression ) : STRING;

		IF ( EXISTS ( EXP.VALUE ) ) THEN
			RETURN ( '\\lceil {' + EXP.VALUE.code_latex + '}\\rceil' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Ceil_Expression_code_ada ( EXP : Symb_Ceil_Expression ) : STRING;

		IF ( EXISTS ( EXP.VALUE ) ) THEN
			RETURN ( ' Double"Ceiling(' + EXP.VALUE.code_ada + ')' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Ceil_WCRT_Expression_code_ada ( EXP : Symb_Ceil_Expression ) : STRING;

		IF ( EXISTS ( EXP.VALUE ) ) THEN
			RETURN ( 'Double"Ceiling(' + EXP.VALUE.code_ada + ')' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	(*floor operation*)
	ENTITY Symb_Floor_Expression 
		SUBTYPE OF ( Symb_Unary_Expression );
	DERIVE
		SELF\Symb_Unary_Expression.operator_type : Symb_Operator_Type := Floor_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Floor_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Floor_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Floor_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Floor_Expression_code_latex ( EXP : Symb_Floor_Expression ) : STRING;

		IF ( EXISTS ( EXP.VALUE ) ) THEN
			RETURN ( '\\lfloor {' + EXP.VALUE.code_latex + '}\\rfloor' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Floor_Expression_code_ada ( EXP : Symb_Ceil_Expression ) : STRING;

		IF ( EXISTS ( EXP.VALUE ) ) THEN
			RETURN ( 'Double''Floor(' + EXP.VALUE.code_ada + ')' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Floor_WCRT_Expression_code_ada ( EXP : Symb_Ceil_Expression ) : STRING;

		IF ( EXISTS ( EXP.VALUE ) ) THEN
			RETURN ( 'Double"Floor(' + EXP.VALUE.code_ada + ')' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	(*a * b*)
	ENTITY Symb_Multiply_Expression 
		SUBTYPE OF ( Symb_Binary_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Operator_Type := Multiplya_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Multiply_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Multiply_Expression_code_ada ( SELF );
		SELF\Generic_Symb_Expression.code_ada_WCRT : STRING := Symb_Multiply_WCRT_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Multiply_Expression_code_latex ( EXP : Symb_Multiply_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( '(' + EXP.lvalue.code_latex + ')'+'*' + '('+EXP.rvalue.code_latex + ')' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Multiply_Expression_code_ada ( EXP : Symb_Multiply_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( '(' + EXP.lvalue.code_ada +')'+ '*' + '('+EXP.rvalue.code_ada + ')' );
		ELSE
			RETURN ( '****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Multiply_WCRT_Expression_code_ada ( EXP :Symb_Multiply_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( '(' + EXP.lvalue.code_ada_WCRT + ')'+'*' +'('+ EXP.rvalue.code_ada_WCRT + ')' );
		ELSE
			RETURN ( '****' );
		END_IF;
	END_FUNCTION;

	(*a <= b*)
	ENTITY Symb_Equal_Less_Expression 
		SUBTYPE OF ( Generic_Symb_Logic_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Logic_Type := Equal_Less_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Equal_Less_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Equal_Less_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Equal_Less_Expression_code_latex ( EXP : Symb_Equal_Less_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( EXP.lvalue.code_latex + '\le' + EXP.rvalue.code_latex );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;


	FUNCTION Symb_Equal_Less_Expression_code_ada ( EXP : Symb_Less_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( EXP.lvalue.code_ada +'
function compute_less_equal 
         (My_Tasks       : in Tasks_Set;
          Processor_Name : in Unbounded_String)
          return boolean
          is
          rightvalue, leftvalue : Double;
          begin ' 
				+  
				 '
          leftvalue :=compute(My_Tasks,To_Unbounded_String("CPU_A")) ; 							 
          rightvalue :=' +EXP.rvalue.code_ada +';
          if (leftvalue <=  rightvalue) then
                 return True;
          else return False;
          end if;
end compute_less_equal;'  );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	(*a < b*)
	ENTITY Symb_Less_Expression 
		SUBTYPE OF ( Generic_Symb_Logic_Expression );
	DERIVE
		SELF\Symb_Binary_Expression.operator_type : Symb_Logic_Type := Less_Type;
		SELF\Generic_Symb_Expression.code_latex : STRING := Symb_Less_Expression_code_latex ( SELF );
		SELF\Generic_Symb_Expression.code_ada : STRING := Symb_Less_Expression_code_ada ( SELF );
	END_ENTITY;

	FUNCTION Symb_Less_Expression_code_latex ( EXP : Symb_Less_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( EXP.lvalue.code_latex + '<' + EXP.rvalue.code_latex );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

	FUNCTION Symb_Less_Expression_code_ada ( EXP : Symb_Less_Expression ) : STRING;

		IF ( EXISTS ( EXP.lvalue ) AND EXISTS ( EXP.rvalue ) ) THEN
			RETURN ( 
EXP.lvalue.code_ada +'
function compute_less 
         (My_Tasks       : in Tasks_Set;
          Processor_Name : in Unbounded_String)
          return boolean
          is
          rightvalue, leftvalue : Double;
          begin ' 
				+  
				 '
          leftvalue :=compute(My_Tasks,To_Unbounded_String("CPU_A")) ; 							 
          rightvalue :=' +EXP.rvalue.code_ada +';
          if (leftvalue <  rightvalue) then
                 return True;
          else return False;
          end if;
end compute_less;' );
		ELSE
			RETURN ( '*****' );
		END_IF;
	END_FUNCTION;

END_SCHEMA;