IA4

(**************************************************************************
 *                                                                        *
 *  File:        Program.fs                                               *
 *  Copyright:   (c) 2016-2017, Florin Leon                               *
 *  E-mail:      florin.leon@tuiasi.ro                                    *
 *  Website:     http://florinleon.byethost24.com/lab_ia.htm              *
 *  Description: Records. Function Composition                            *
 *               (Artificial Intelligence lab 4)                          *
 *                                                                        *
 **************************************************************************)

module Program1 =

    let lastButTwo1 list =
        list |> List.rev
            |> List.tail
            |> List.tail
            |> List.head
       // cu |>

    let lastButTwo2 =
        List.rev >> List.tail
            >> List.tail
            >> List.head
        // cu >>

    let mainP1() =
        let list =  [ 1..10 ]
        printfn "Antepenultimul element: %A" (lastButTwo1 list)
        printfn "Antepenultimul element: %A" (lastButTwo2 list)

// ==========================================================

module Program2 =

    let discountedSum list =
        if List.length list < 3 then
            List.sum list
        else
            list |> List.sort
                |> List.rev
                |> List.mapi (fun i x -> if i=1 then 0.9*x elif i=2 then 0.8*x else x)
                |> List.sum
      // daca lista are mai putin de 3 elemente, se face suma simpla
      // altfel: se sorteaza descrescator lista
      // se face o transformare a listei, in care al doilea element este inmultit cu 0.9, al treilea cu 0.8, iar celelalte raman neschimbate
      // se sumeaza elementele

    let mainP2() =
        let list = [ 20.0; 10.0; 30.0 ]
        printfn "Preturile articolelor fara reduceri: %A" list
        printfn "Suma fara reduceri: %.2f" (List.sum list)
        printfn "Suma finala: %.2f\n" (discountedSum list)

        let list = [ 10.0; 20.0 ]
        printfn "Preturile articolelor fara reduceri: %A" list
        printfn "Suma fara reduceri: %.2f" (List.sum list)
        printfn "Suma finala: %.2f\n" (discountedSum list)

// ==========================================================

module Program3 =

    open System
    open System.IO

    let list =
        let lineToTuple (line : string) =
            let toks = line.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
            (toks.[0], toks.[1], toks.[2])
        File.ReadAllLines "kinship.csv"
        |> List.ofSeq
        |> List.map lineToTuple

    let findParents1() =
        let mothers = List.filter (fun (a, _, _) -> a = "mother") list
        let fathers = List.filter (fun (a, _, _) -> a = "father") list
        [
            for (_, m, c1) in mothers do
                for (_, f, c2) in fathers do
                    if c1 = c2 then
                        yield (m, f, c1)
        ]

    let getParent child parentType =
        let (pT, p, c) = list |> List.find (fun (pT,p,c) -> pT=parentType && c=child)
        p

    let findParents2() =
        list |> List.filter (fun (a, _, _) -> a="mother" || a="father")
            |> List.map (fun (_,_,c) -> c)
            |> Seq.distinct
            |> List.ofSeq
            |> List.map (fun child -> ((getParent child "mother"), (getParent child "father"), child))
        // se filtreaza lista, ramanand numai elementele cu relatiile "mother" sau "father"
        // se transforma aceasta lista intr-o lista de copii
        // se elimina duplicatele: Seq.distinct |> List.ofSeq
        // se transforma lista copiilor intr-o lista de tuple de forma ((getParent c "mother") , (getParent c "father"), c)
        // functia getParent trebuie implementata, folosind functia List.find
        // orice alta abordare functionala este binevenita

    let printParents parents =
        List.iteri (fun i (m, f, c) -> printfn "%d. mama %s / tata %s / copilul %s" (i + 1) m f c) parents

    let mainP3() =
        printfn "Metoda imperativa\n"
        findParents1() |> printParents

        printfn "\nMetoda functionala\n"
        findParents2() |> printParents

// ====================================================================

module Program4 =
    type Person = {
        FirstName: string;
        LastName: string;
        Age: int;
    }

    let mainP4a() =
        let persons = [("Ion", "Popescu", 23); ("George", "Ionescu", 24); ("Alexandru", "Georgescu", 21)]
        let t = List.sortBy (fun (prenume, nume, varsta) -> nume) persons
        printfn "Persoanele sortate:"
        List.iter (fun (prenume, nume, varsta) -> printfn "%s %s - %d ani" nume prenume varsta) t

    let mainP4b() =
        printfn "Records"
        let persons = [{FirstName="Ion"; LastName="Popescu"; Age=23}; {FirstName="George"; LastName="Ionescu"; Age=24}; {FirstName="Alexandru"; LastName="Georgescu"; Age=21}]
        printfn "Persoanele sortate:"
        persons |> List.sortBy (fun persoana -> persoana.LastName)
            |> List.iter (fun persoana -> printfn "%s %s - %d ani" persoana.LastName persoana.FirstName persoana.Age)
        // functia rescrisa folosind o intregistrare si operatorul pipe

// ====================================================================

[<EntryPoint>]
let main argv =
    Program1.mainP1()
    Program2.mainP2()
    Program3.mainP3()
    Program4.mainP4a()
    Program4.mainP4b()
    System.Console.ReadKey()
    0