(* TD5 exo26 *)

(*Q1 et Q2*)

(* premiere version *)
let rec simple_average_ue_aux(marks : float list) : float * int =
    if marks = [] then (0.0, 0)
    else let (m, r) : float * float list = (fst(marks), rem_fst(marks)) in
        let (mark_r, nb_r) : float * int = simple_average_ue_aux(r) in
            (m +. mark_r, nb_r + 1)
;;

let simple_average_ue(marks : float list) : float =
    let (sum_marks, nb_marks) : float * int = simple_average_ue_aux(marks) in
    if nb_marks = 0
    then failwith("erreur simple_average_ue : pas de notes")
    else sum_marks /. float_of_int(nb_marks)
;;

(* seconde version: On remarquera que les données liées au pb sont
ici communiquées via les arguments entre les différents appels récursifs*)

let rec simple_average_ue_aux(marks, sum, nb : float list * float * int) : float * int =
    if marks = []
    then (sum, nb)
    else
        let (m, r) : float * float list = (fst(marks), rem_fst(marks)) in
        simple_average_ue_aux(r, m +. sum, nb + 1)
;;

let simple_average_ue(marks : float list) : float =
    let (sum_marks, nb_marks) : float * int = simple_average_ue_aux(marks, 0.0, 0) in
    if nb_marks = 0
    then failwith("erreur simple_average_ue : pas de notes")
    else sum_marks /. float_of_int(nb_marks)
;;

(* Q3 *)
(* premiere version *)
let rec average_ue_aux(marks, coeffs : float list * int list) : float * int =
if marks = []
then
    if coeffs = []
    then (0.0, 0)
    else failwith("erreur average_ue_aux : moins de notes que de coeffs")
else
    if coeffs = []
    then failwith("erreur average_ue_aux : moins de coeffs que de notes")
    else
        let (m, m_r) : float * float list = (fst(marks), rem_fst(marks))
        and (c, c_r) : int * int list = (fst(coeffs), rem_fst(coeffs))in
            let (mark_r, coeff_r) : float * int = average_ue_aux(m_r, c_r) in
                (m *. float_of_int(c) +. mark_r, c + coeff_r)
;;

let average_ue(marks, coeffs : float list * int list) : float =
    let (sum_marks, sum_coeffs) : float * int = average_ue_aux(marks, coeffs) in
    if sum_coeffs = 0
    then failwith ("erreur average_ue : somme des coeffs nulle")
    else sum_marks /. float_of_int(sum_coeffs)
;;

(* seconde version avec communiqcation de resultats intermédiaires via des parametres ad hoc *)
let rec average_ue_aux(marks, coeffs, sum_marks, sum_coeffs : float list * int list * float * int) : float * int =
    if marks = []
    then
        if coeffs = []
        then (sum_marks, sum_coeffs)
        else failwith("erreur average_ue_aux : moins de notes que de coeffs")
    else
        if coeffs = []
        then failwith("erreur average_ue_aux : moins de coeffs que de notes")
        else
            let (m, m_r) : float * float list = (fst(marks), rem_fst(marks))
            and (c, c_r) : int * int list = (fst(coeffs), rem_fst(coeffs))in
                average_ue_aux(m_r, c_r, m *. float_of_int(c) +. sum_marks, c + sum_coeffs)
;;

let average_ue(marks, coeffs : float list * int list) : float =
    let (sum_marks, sum_coeffs) : float * int = average_ue_aux(marks, coeffs, 0.0, 0) in
        if sum_coeffs = 0
        then failwith("erreur average_ue : pas de notes")
        else sum_marks /. float_of_int(sum_coeffs)
;;

(* Q5 et Q6  : liste de (liste de notes) ex: "(float list) list" *)

let rec average_stud_aux(marks_stud, coeffs_year : (float list) list * (int list) list) : float*int =
if marks_stud = []
then
    if coeffs_year = []
    then (0.0, 0)
    else failwith("erreur average_stud ; moins de notes que d’UEs")
else
    if coeffs_year = []
    then failwith("erreur average_stud ; moins de coeffs que d’UEs")
    else
        let (mark_ue, rem_mark_ue) : float list * (float list) list = (fst(marks_stud), rem_fst(marks_stud))
        and (coef_ue, rem_coef_ue) : int list * (int list) list = (fst(coeffs_year), rem_fst(coeffs_year))in
            let (mark, nb) : float * int = average_stud_aux(rem_mark_ue, rem_coef_ue) in
                (mark +. average_ue(mark_ue, coef_ue), nb + 1)
;;

let rec average_stud(marks_stud, coeffs_year : (float list) list * (int list) list) : float =
    let (mark, nb) : float * int = average_stud_aux(marks_stud, coeffs_year) in
        if nb = 0
        then failwith("erreur average_stud : pas de notes")
        else mark /. float_of_int(nb)
;;

(* seconde version avec passage des resultats intermédiaires via les arguments *)
let rec average_stud_aux(marks_stud, coeffs_year, sum, nb : (float list) list * (int list) list * float * int) : float * int =
    if marks_stud = []
    then
        if coeffs_year = []
        then (sum, nb)
        else failwith("erreur average_stud ; moins de notes que d’UEs")
    else
        if coeffs_year = []
        then failwith("erreur average_stud ; moins de coeffs que d’UEs")
        else
            let (mark_ue, rem_mark_ue) : float list * (float list) list = (fst(marks_stud), rem_fst(marks_stud))
            and (coef_ue, rem_coef_ue) : int list * (int list) list = (fst(coeffs_year), rem_fst(coeffs_year))in
                let mark : float = average_ue(mark_ue, coef_ue) in
                    average_stud_aux(rem_mark_ue, rem_coef_ue, sum +. mark, nb + 1)
;;

let rec average_stud(marks_stud, coeffs_year : (float list) list * (int list) list) : float =
    let (mark, nb) : float * int = average_stud_aux(marks_stud, coeffs_year, 0.0, 0) in
        if nb = 0
        then failwith("erreur average_stud : pas de notes")
        else mark /. float_of_int(nb)
;;

(*Q7 et Q8*)
Non pas de corrections, oublier ces 2 questions.

(* si vraiment vous y tenez, mais juste pour envisager l'idée de listes de (liste de (liste de notes))) *)
let rec average(l_marks, coeffs_year : ((float list) list) list * (int list) list) : float list =
    if l_marks = []
    then []
    else
        let (stud, rem_stud) : (float list) list * ((float list) list) list = (fst(l_marks), rem_fst(l_marks)) in
            add_fst(average(rem_stud, coeffs_year), average_stud(stud, coeffs_year))
;;

let rec average_aux(l_marks, coeffs_year, res : ((float list) list) list * (int list) list * float list) : float list =
    if l_marks = []
    then res
    else
        let (stud, rem_stud) : (float list) list * ((float list) list) list = (fst(l_marks), rem_fst(l_marks)) in
            let m : float = average_stud(stud, coeffs_year) in
                average_aux(rem_stud, coeffs_year, add_lst(res, m))
;;

let rec average(l_marks, coeffs_year : ((float list) list) list * (int list) list) : float list =
    average_aux(l_marks, coeffs_year, [])
;;

(*Q27: Memorisarion dans des listes des termes de la suite de Fibbonacci *)

(* pour rappel la corrextion de ex8 du chap4*)
let rec fibonacci_V1_aux(n : int) : int * int =
    if n = 1
    then (1, 1)
    else
        let (prev, cur) : int * int = fibonacci_V1_aux(n-1) in
        (cur, prev + cur)
;;

let fibonacci_V1(n : int) : int =
    if n < 0
    then failwith "erreur fibonacci_V1 : parametre strictement negatif"
    else
        if n = 0
        then 1
        else
            let (prev, cur) : int * int = fibonacci_V1_aux(n) in
            cur
;;

(* mémorisation dans un liste  - ce qui esr demandé ds la Q7 donc - *)
let rec fibonacci_V1_aux(n : int) : int * int * int list =
    if n = 1
    then (1, 1, [1 ; 1])
    else
        let (prev, cur, prevlist) : int * int * int list = fibonacci_V1_aux(n-1) in
            let newval : int = prev + cur in
            (cur, newval, add_lst(prevlist, newval))
;;

let fibonacci_V1(n : int) : int list =
    if n < 0
    then failwith "erreur fibonacci_V1 : parametre strictement negatif"
    else
    if n = 0
    then [1]
    else
        let (prev, cur, fibo) : int * int * int list = fibonacci_V1_aux(n) in
            fibo
;;


(* seconde correction, avaec resultat intermédiaire dans les parametres *)
let rec fibonacci_V2_aux(n, i, prev, cur, cur_list :int * int * int * int * int list) : int list =
    if i = n
    then cur_list
    else
        let (new_i, new_prev, new_cur) : int * int * int = (i+1, cur, prev+cur) in
            let new_list : int list = add_lst(cur_list, new_cur) in
                fibonacci_V2_aux(n, new_i, new_prev, new_cur, new_list)
;;

let fibonacci_V2(n : int) : int list =
    if n < 0
    then failwith "erreur fibonacci_V2 : parametre strictement negatif"
    else
        if n = 0
        then [1]
        else fibonacci_V2_aux(n, 1, 1, 1, [1 ; 1])
;;