moins

moins.c

/*

Profil:
###### 

moins: entier_nat x entier_nat -> entier_nat

Exemples:
###### 

moins(3,2) = 1
moins(2,3) = Erreur
moins(5,0) = 5

on degage les axiomes des exemples:

moins(3,2) = moins(2,1) = moins(1,0) = 1

Axiomes:
###### 

moins(x, 0) = x
moins(0, succ(y)) = Erreur
moins(succ(x), succ(y)) = moins(x, y)

Algorithme recursif:
###### 

fonction moins(x: entier_nat, y: entier_nat): entier_nat
debut
 | si est_nul(y)
 | -------------
 |               | alors retourner x
 |               | sinon            
 |               | si est_nul(x)    
 |               |                   | alors Erreur                           
 |               |                   | sinon retourner moins(prec(x), prec(y))
 |               | finsi            
 | finsi        
fin

Algorithme iteratif:
###### 

fonction moins(x: entier_nat, y: entier_nat): entier_nat
debut
 | tantque (non est_nul(x)) et (non est_nul(y)) faire
 | --------------------------------------------------
 |                                                    | x := prec(x)     
 |                                                    | y := prec(y)     
 | fintantque                                        
 | si est_nul(y)                                     
 |                                                    | alors retourner x
 |                                                    | sinon Erreur     
 | finsi                                             
fin

*/

#include "entier_nat.h"

#include `<stdbool.h>`
#include `<stdio.h>`

ENTIER_NAT moins_recursif(ENTIER_NAT x, ENTIER_NAT y)
{
    if (est_nul(y))
    {
    return x;
    }
    else
    {
    if (est_nul(x))
    {
      Erreur_Entier_Nat();
    }
    return moins_recursif(prec(x), prec(y));
    }
}

ENTIER_NAT moins_iteratif(ENTIER_NAT x, ENTIER_NAT y)
{
    while ( (! est_nul(x)) && (! est_nul(y)) )
    {
    x = prec(x);
    y = prec(y);
    }
    if (! est_nul(y))
    { 
    Erreur_Entier_Nat();
    }
    return x;
}

void test_recursif(ENTIER_NAT a, ENTIER_NAT b)
{
    ENTIER_NAT c;
    c = moins_recursif(a, b);
    printf("recursif: %d - %d = %d\n", a, b, c);
}

void test_iteratif(ENTIER_NAT a, ENTIER_NAT b)
{
    ENTIER_NAT c;
    c = moins_iteratif(a, b);
    printf("iteratif: %d - %d = %d\n", a, b, c);
}

int main()
{
   test_recursif(5,3);
   test_recursif(3,3);
   test_iteratif(5,3);
   test_iteratif(3,3);
   test_iteratif(3,5);
}