Langage ada apres c++ et c

bonne nuit


whith racine_caree,e_s_simple;
procedure imprimer_racine is
use e_s_simple ;
begin
imprimer (racine_carree(2.5))

end imprimer_racine;

use e_s_simples;
e_s_simples.imprimer (racine_carree(2.5));


whith racine_carree,e_s_simple;
procedure imprimer_racine is
use e_s_simples;
x:float;
begin
pendre (x);
imprimer (racine_carre (x));
end imprimer_racine;

with racine_carre,e_s_simples;
procedure imprimer_racine is
use e_s_simples;
x:float;
begin
imprimer("racines de divers nombres");
saut_ligne (2);
loop
prendre (x);
exit when x=0.0;
imprimer ("racine de ");
imprimer (x);
imprimer("est");
if x<.0 then
imprimer ("incalculable");
else
imprimer (racine_carree(x));
end if;
saut_ligne;
end loop;
saut_ligne;
imprimer ("fin du programme");
saut_ligne;
end imprimer_racines;

fonction racine_carree a une autre structure:

fonction racine_carree (f:float) return float is
R:float;
begin
--calculer la valeur de racine_carree(f) dans r
return r;
end racine_carree;


Le paquetage e_s_simples (procedures):

package e_s_simples is
procedure prendre (f:out float);
procedure imprimer (f:in float);
procedure imprimer (s:in string);
procedure saut_ligne (n:in integer:=1);
end e_s_simples;
le parametre de prendre est un parametre out
par ce que l'effet d'appeler prendre,
comme dans:
prendre (x);


le corp de paquetage :
whith text_io
package body e_s_simples is
...
procedure prendre (f:out float) is
...
begin
...
end prendre;
-- Autres procedures
end e_s_simples;


execice

en pratique,il est vraisemblable que la
fonctin racine_carre ne sera pas isolée
dans la bibliotheque,mais dans un paquetage
avec d'autre fonctions mathematiques,suposons
que ce paquetage a l'identificateur math_simples
et que les autres fonctions sont log,
exp,sin,et cos par analogie avec la specification
de e_s_simples,ecrire la specification de
e_s_simple,écrire la specification d'un tel paquetage
.comment notre procedure imprimer_racine doit elle etre
modifiee?

1 package maths_simples is
function rac2(f:float) return float;
function log(f:float) return float;
function ln(f:float) return float;
function exp (f:float) return float;
function sin (f:float) return float;
finction cos (f:float) return float;
end math_simples;

whith math_simples,es_simples;
procedure imprimer_racine is
use maths_simples,es_simples;



erreurs et exeptions:
nous pourrions remplacer l'instruction conditionnelle:
if x<0.0 then
imprimer ("incalculable");
else
imprimer (racine_carree(x));
end if;
par
begin
impimer (racine_carree(x));
exception
when constraint_error=>
imprimer("incalculable");
end;

declare
type couleur is (rouge,orange,vert);
type poisson is (morue,merlu,lieu_noir);
x,y:couleur;
a,b:poisson;
begin
x:=rouge; --c'est bon
a:=merlu; --c'est bon
b:=x; --illegale
...
end;
presque la meme chose qu'un type existant
type lumiere is new couleur;

declare
type lumiere is new couleur;
c:couleur;
l:lumiere;
begin
l:=orange; --la lumiere orange et non la couleur
c:=couleur (L); --conversion explcite
...
end;
tantdis qu'une affectation directe
c:=L; --illégal

le paquetage generique entrees , sorties
des valeurs point-flottant

un paqeutage s'occupe de tous les types
qui sont definie par exemple pour les fonction

generic
type num is digits<>;
package float_io is
...
procedure get(item:out num;...);
procedure put (item:in num;...);
...
end float_io;

afin de crée un paqueage effectif pour manipuler
les valeurs de notre type reel,nous ecrivons (*pas compris*)
package e_s_reel is new float_io(reel);


whih exceptions_des_fonctions_elementaires;(*j'ai compris :les erreures*)
generic (*pour un package s'occupe*)
type type_flottant is digits<>; (*7 chiffre decimaux)
package fonction_elementaire_generique is (*package de fonction*)
function rac2(x:type_flottant) return type_flottant;
(*c'est claire resultat point flottant*)
... --etc.
end;