program exo02
    implicit none

    integer :: n
    real :: u
    print *, "Entrez un entier strictement positif : "
    read *, n

    u = suite(n)
    print *, u

    contains

    function suite(n) result(u)
        integer, intent(in) :: n
        ! return
        real    :: u
        ! locals
        real    :: um1=1., um2=3.
        integer :: i
        

        select case (n)
            case ( : 0 )
                print *, "n=", n
                stop "Err. [suite]: J'avais dit > 0 !"
            case (1)
                u = um1
            case(2)
                u = um2
            case default
                do i=1,n
                    u   = 1/um2 + um1
                    um2 = um1
                    um1 = u
                end do
        end select
    end function suite
    
end program exo02

program exo02
    implicit none

    integer :: nmax
    real    :: seuil, u
    logical :: exist

    print *, "Entrez un entier strictement positif : "
    read *, nmax
    ! Test si nmax est strictement positif et quitte le programme sinon
    if (nmax<=0) then
        stop "Tu es tetu ! J'ai dit posiiiitif !"
    end if

    print *, "Entrez un seuil >0 (valeur minimale)"
    read *, seuil
    if (seuil<=0) then
        stop "Tu es tetu ! J'ai dit posiiiitif !"
    end if

    call lookfor(nmax, seuil, u, exist)

    if (exist .eqv. .true.) then
        print *, u
    else
        print *, "Valeur non atteinte"
    end if

    contains

    subroutine lookFor(nmax, seuil, u, exist)
        implicit none 

        integer, intent(in   ) :: nmax
        real   , intent(in   ) :: seuil
        real   , intent(  out) :: u
        logical, intent(  out) :: exist
        ! locals
        integer :: i=3
        real    :: um1=1., um2=3.

        exist = .false.
        ! On ne peut pas utiliser de select case ici car seuil est un réel
        if ( um1 > seuil) then
            exist = .true.
            u = um1
        else if (um2 > seuil) then
            exist = .true.
            u = um2
        else
            do while (i<nmax)

                u = 1/um2 + um1
                um2 = um1
                um1 = u

                if (u > seuil) then
                    i     = nmax     ! Quit the do while
                    exist = .true.
                end if 
                i = i + 1
            end do
        end if
    end subroutine lookFor
end program exo02

program tab_argumemt
    implicit none
    real, dimension(0:3) :: poly 
    real :: x

    poly = (/3,5,0,3/)

    x = 5.
    x = eval_poly(poly, x)
    print *, x

    call double_pair_coefficient(poly)

    x = 5.
    x = eval_poly(poly, x)
    print *, x

    contains

    subroutine double_pair_coefficient(poly)
        implicit none
        ! Attention avec cette déclaration on aura un polynome dont le premier
        ! indice est toujours 1 et ce même si le polynome entré a un premier indice
        ! différent
        real, dimension(:), intent(inout) :: poly
        ! locals
        integer :: i

        ! Note 1 :
        !   pour un tableau dont la numérotation commence a 0, le dernier
        !   element est à la position size(A)-1
        ! Note 2 :
        !   la case d'indice 0 contient le coefficient de plus haut degré
        !   la dernier case contient le terme de degré 0
        ! Note 3 :
        !   la derniere case contient toujours un coefficient associé à un
        !   degré pair. Donc commencons par la dernière case
        do i = size(poly), 1, -2
            poly(i) = 2 * poly(i) 
        end do

    end subroutine double_pair_coefficient

    function eval_poly(poly, x) result(rslt)
        implicit none
        real, dimension(:), intent(in) :: poly
        real              , intent(in) :: x
        ! Returns
        real :: rslt
        ! Locals
        integer :: i, degre

        ! 1er indice est 1 donc degre est la taille du vecteur
        degre = size(poly)

        rslt = 0.
        do i = 1, degre
            rslt = rslt + poly(degre-i) * x**(i-1)
        end do
    end function eval_poly
end program tab_argumemt