// Learn more about F# at http://fsharp.net
// See the 'F# Tutorial' project for more help.
open System
exception UJEMNY_ARGUMENT

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////Funkcje, funkcje rekurencyjne, operacje na łańcuchach znaków////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

//Zadeklaruj funkcję obliczająca n!. Funkcja przyjmuje jeden parametr (n) oraz zwraca
//wynik obliczeń. W przypadku podania ujemnej wartości n funkcja powinna wyrzucić wyjątek UJEMNY_ARGUMENT.
let rec silnia n =
    match n with
    | n when n < 0 -> raise UJEMNY_ARGUMENT
    | 0 -> 1
    | _ -> n* silnia(n-1)

//Zadeklaruj funkcję obliczającą ab, dla b>0. Funkcja przyjmuje dwa parametry (a i b) oraz zwraca wynik obliczeń.
let rec adob (a:int, b:int) =
    match b with
    | 0 -> 1
    | _ -> a * adob(a, b-1)

//Zadeklarować funkcję, która obliczy i zwróci n-ty element ciągu Fibonacciego. Wskazówka: F(n)=1, dla n=0 i n=1
//F(n)=F(n-1)+F(n-2), dla n>1.
let rec fibon n:int =
    match n with
    | 0 -> 1
    | 1 -> 1
    | _ -> fibon(n-1) + fibon(n-2)

//Zrealizuj funkcję mRn wykonującą mnożenie liczb całkowitych poprzez rekurencyjne dodawanie wykorzystując zależności:
//m*n = m*0 = 0; dla n=0
//m*n = m*1 = m; dla n=1
//m*n = m + m*(n-1) dla n>0.
let rec mRn (m:int, n:int) =
    match n with
    | 0 -> 0
    | 1 -> m
    | _ -> m + mRn(m,n-1)

//Napisz funkcję niePodzielny: int*int->bool, gdzie niepodzielny(d, n) zwróci wartość false,
//jeśli d jest podzielne przez n i true w przeciwnym przypadku.

let NiePodzielny (d:int, n:int) =
    let np = d%n
    match np with
    | 0 -> false
    | _ -> true

//Zadeklaruj funkcję liczWyst: string*char -> int, która zlicza wystąpienia znaku ch w łańcuchu str.
let liczWyst (str: string, ch:char) =
    let ilosc = ref(0)
    let dl = str.Length
    for i=0 to dl-1 do
        if str.[i] = ch then incr(ilosc)
    ilosc.Value

//Zadeklaruj funkcję liczWystOd: string*int*char -> int, która zlicza wystąpienia znaku ch
//w łańcuchu str od pozycji j do końca łańcucha.

let liczWystOd(str: string,ile:int, ch:char) =
    let ilosc = ref(0)
    let dl = str.Length
    for i=ile to dl-1 do
        if str.[i] = ch then incr(ilosc)
    ilosc.Value

//Zadeklaruj funkcje pow: string*int->string, która zwróci łańcuch, będący sumą n powtórzeń
//łańcucha str, np. pow(str, n) dla str=”Tak” i n=3 zwróci łańcuch „TakTakTak”.
let pow (str: string, n:int) =
    match n with
    | 1 -> str
    | _ -> String.replicate n str

///////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////Krotki i rekordy///////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

//Napisać funkcję wyznaczającą największy wspólny dzielnik NWD liczb m i n (NWD: int*int -> int).
let rec NWD (m:int, n:int) =
    match n with
    | 0 -> m
    | _ -> NWD(n,m%n)

//Zadeklaruj funkcje realizujące podstawowe operacje na ułamkach: dodawanie (++), odejmowanie (--),
//mnożenie (**), dzielenie (/./). W przypadku wystąpienia 0 w mianowniku funkcje powinny zwracać
//wyjątek exception DzieleniePrzezZero.

exception DzieleniePrzezZero

let ( ++ ) (a,b)(c,d) =
    if b*d = 0 then raise DzieleniePrzezZero
    else a * d + c * b , b * d

let ( -- ) (a,b)(c,d) =
    if b*d = 0 then raise DzieleniePrzezZero
    else a * d - c * b , b * d

let ( ** ) (a,b)(c,d) =
    if b*d = 0 then raise DzieleniePrzezZero
    else a * c, b * d

let ( /./ ) (a,b)(c,d) =
    if b*d = 0 then raise DzieleniePrzezZero
    else a * d, b * c

// Napisz funkcję skracającą ułamek (wykorzystaj funkcję NWD: int*int -> int).
let skr (a:int, b:int) =
    let znak = if a<0 then -1 else 1
    let li = abs a
    let mi = abs b
    let dzielnik = NWD (li,mi)
    let li2 = znak * (li/dzielnik)
    let mi2 = mi / dzielnik
    li2,mi2

//Zadeklaruj funkcję naString, która zmieni ułamek na łańcuch naString: int*int->string.
//Ułamek powinien być wyświetlony w postaci właściwej, czyli jako część całkowita i ułamkowa.
let naString(a:int, b:int) =
    let znak = if a<0 then "-" else ""
    let li = abs a
    let mi = abs b
    let dzielnik = NWD (li,mi)
    let calk = li/mi
    let calkowita = if calk = 0 then "" else calk.ToString()
    let li2 = ((li-calk*mi)/dzielnik)
    let mi2 = mi / dzielnik
    znak.ToString() + calkowita.ToString() + " " + li2.ToString() + "/" + mi2.ToString()

//Zadeklaruj funkcje realizujące funkcje arytmetyczne dla liczb zespolonych:
//dodawanie (++), odejmowanie (--), mnożenie (**), dzielenie (/./).

let (+++) (a,b) (c,d) =
    let znak = if b+d >0 then "+" else "-"
    (a+c).ToString() + znak + (b + d).ToString() + "i"

let (---) (a,b) (c,d) =
    let znak = if b-d >0 then "+" else "-"
    (a-c).ToString() + znak + (b - d).ToString() + "i"

let ( *** ) (a,b) (c,d) =
    let znak = if b*d >0 then "+" else "-"
    ((a*c)-(b*d)).ToString() + znak + ((a*d)+(b*c)).ToString() + "i"

let (/././) (a,b) (c,d) =
    if c=0 && d=0 then raise DzieleniePrzezZero
    (a,b) *** (c,-d) + "/" + (c*c + d*d).ToString()

///Zadeklaruj funkcję pierwsza: int -> bool, gdzie pierwsza (n)=true wtedy i tylko wtedy,
//gdy n jest liczba pierwszą. Wsk.: Liczba pierwsza to taka, której podzielnikami są tylko 1
//i ona sama. Skonstruuj funkcję pomocniczą pierwsza’ z dwoma wariantami (kończącym rekurencję)
//pierwsza’(n,2) i pierwsza’(n,k) wywoływaną przez zasadniczą: let pierwsza n = pierwsza' (n,n-1).

let rec pierwsza'(n:int,k:int) =
    let r = n%k
    match k with
    | 1 -> true
    | _ -> match r with
        | 0 -> false
        | _ -> pierwsza'(n,k-1)

let pierwsza n =
    pierwsza'(n,n-1)

//Utwórz następujące funkcje: 1) mnożenia ułamka przez liczbę; 2) dzielenia ułamka przez liczbę;
//3) pierwiastkowania ułamka. Napisz funkcję zwracającą odwrotność ułamka.

let mululamek (liczba:int, licznik:int, mianowknik:int ) =
    licznik * liczba , mianowknik

let divulamek (liczba:int, licznik:int, mianowknik:int ) =
    licznik , mianowknik * liczba

let sqrtulamek (licznik:float, mianowknik:float ) =
   sqrt (licznik) , sqrt (mianowknik)

//Utwórz rekord zawierający dane studenta (imie, naziwsko, indeks) i zadeklaruj kilka rekordów
//zawierających dane studentów. Napisz funkcję sprawdzającą czy dwie osoby mają to samo nazwisko.
type student = {imie: string; nazwisko: string; indeks:int}

let SprawdzStudenty (lista: student list) =
    let dl = lista.Length
    let ilosc = ref(0)
    for i = 0 to dl-1 do
        for k = 0 to dl-1 do
            if lista.[i].nazwisko = lista.[k].nazwisko then incr(ilosc)

    if ilosc.Value > dl then true else false

///////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////Listy funkcje lambda//////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

//Podaj deklarację funkcji typu int list -> int option odszukującej najmniejszy element z listy liczb całkowitych.
let findmin (lista:int list)=
    List.min lista

//Zaproponuj deklarację funkcji length wyznaczającej długość listy.

let rec lengh (lista:int list, l:int) =
    match lista with
    | head :: ogon -> lengh(ogon,l+1)
    | head -> l

let listlenght (lista:int list) =
    lengh(lista,0)

//Zadeklaruj funkcję krotnosc(x,ys), która podaje ile razy element x występuje na liście ys.
let krotnosc (x:int, ys:int list) =
    let ile = ref(0)
    List.iter(fun y -> if y = x then incr(ile)) ys
    ile.Value

//Podaj definicję funkcji n-ty typu 'a list*int -> 'a option, która zwraca n-ty element na podanej liście (licząc od zera)
let nelem (lista:int list, x:int) =
    lista.[x]

//Napisz funkcję sprawdzającą, czy wszystkie całkowite elementy listy typu int są nieujemne.
let CzyUjemne ( lista: int list) =
    let ile = ref(0)
    List.iter(fun x -> if x<0 then incr(ile)) lista
    if ile.Value = lista.Length then true else false



///////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////Klasy/////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

[<AbstractClass>]
type figura(P) =
    inherit Object()
    let mutable Pole = P

    member this.pole
        with get() = Pole
        and set(value:float) = Pole <- value

    abstract member ObliczPole: unit -> float

type Trójkąt(ba,bb,bc) =
    inherit figura(0.0)
    let mutable a:float = ba
    let mutable b:float = bb
    let mutable c:float = bc

    override this.ObliczPole() =
        let p = (a+b+c)/2.0
        base.pole <- sqrt(p*(p-a)*(p-b)*(p-c))
        base.pole

[<EntryPoint>]
let main argv =
    ///////////////////////////////////////////////////////////////////////////////////////////////
    printfn "-------------------------------------------------------------------------------"
    printfn "----------Funkcje funkcje rekurencyjne, operacje na łańcuchach znaków----------"
    printfn "-------------------------------------------------------------------------------"
    ///////////////////////////////////////////////////////////////////////////////////////////////
    let sil = silnia 3
    printfn "Silnia 3= %A" sil

    let ab = adob(2, 10)
    printfn "2 do potego 10= %A" ab

    let fib = fibon(5)
    printfn "Fibonacci 5 = %A" fib

    let mn = mRn(5,5)
    printfn "5 x 5 = %A" mn

    let np = NiePodzielny(15,4)
    printfn "Czy niepodzielne 15 / 4  = %A" np

    let st = "Ala ma Kooota"
    let np = liczWyst(st,'o')
    printfn "Znak O występuje w Ala ma Kooota %A razy" np

    let st2 = "Ala ma Kooota "
    let np = liczWystOd(st2,3,'a')
    printfn "Znak A występuje w Ala ma Kooota %A razy, liczac od 3 znaku" np

    let xrazy = pow(st2,4)
    printfn "Tekst %A powolono 4 razy :%A" st2 xrazy
    ///////////////////////////////////////////////////////////////////////////////////////////////
    printfn "-------------------------------------------------------------------------------"
    printfn "-------------------------------Krotki i rekordy--------------------------------"
    printfn "-------------------------------------------------------------------------------"
    ///////////////////////////////////////////////////////////////////////////////////////////////
    let nw = NWD(600,400)
    printfn "NWD licz 600 i 400 to %A" nw

    let li,mi = (3,5) ++ (3,4)
    printfn "3/5 + 3/4 = %A / %A" li mi

    let li,mi = (3,5) -- (3,4)
    printfn "3/5 - 3/4 = %A / %A" li mi

    let li,mi = (3,5) ** (3,4)
    printfn "3/5 * 3/4 = %A / %A" li mi

    let li,mi = (3,5) /./ (3,4)
    printfn "3/5 / 3/4 = %A / %A" li mi

    let li,mi = skr (10,35)
    printfn "10/35 = %A / %A" li mi

    let stt = naString (-40,35)
    printfn "-40/35 = %A " stt

    let z1= (3,5) +++ (3,4)
    printfn "3+5i + 3+4i = %A" z1

    let z1= (3,5) --- (3,4)
    printfn "3+5i - 3+4i = %A" z1

    let z1= (3,5) *** (3,4)
    printfn "3+5i * 3+4i = %A" z1

    let z1= (3,5) /././ (3,4)
    printfn "3+5i / 3+4i = %A" z1

    let pier1= pierwsza 10
    let pier2= pierwsza 11
    printfn "Czy 10 jest liczba pierwsza: %A, a czy 11 nia jest :%A" pier1 pier2

    let ddd,mmm= mululamek(5,3,5)
    printfn "3/5 * 5 = %A / %A" ddd mmm

    let ddd,mmm= divulamek(5,3,5)
    printfn "3/5  / 5  =  %A / %A" ddd mmm

    let ddd,mmm= sqrtulamek(9.0,12.0)
    printfn "pierwiastek z 9/12 =  %A / %A" ddd mmm

    let maciek = {imie =  "Maciek";nazwisko =  "Nowak"; indeks =  123452}
    let jan = {imie =  "Jan";nazwisko =  "Nowak"; indeks =  323233}
    let Czesiek = {imie =  "Czesław";nazwisko =  "Kowalski"; indeks =  121212}
    let studenty = [jan;maciek;Czesiek]
    let stt = SprawdzStudenty studenty
    printfn "Czy jest dwóch studentów o takim samym nazwisku: %A" stt

    ///////////////////////////////////////////////////////////////////////////////////////////////
    printfn "-------------------------------------------------------------------------------"
    printfn "----------------------------Listy i funkcje lambda-----------------------------"
    printfn "-------------------------------------------------------------------------------"
    ///////////////////////////////////////////////////////////////////////////////////////////////

    let liss = [3;2;5;4;3;2;1;5;6;4;-2;5;6]
    let min = findmin liss
    printfn "Najmniejszy element z listy %A  to %A" liss min

    let dl = listlenght liss
    printfn "Lista %A  ma  %A elementów" liss dl

    let il = krotnosc( 3, liss)
    printfn "Element 3 jest na liscie %A razy" il

    let il = nelem( liss, 5)
    printfn "Elementem 5 na liscie jest %A " il

    let il = CzyUjemne(liss)
    let lisss = [-3;-2;-5;-4;-3;-2;-1;-5;-6;-4;-2;-5;-6]

    let ili = CzyUjemne(lisss)
    printfn "Czy wszystkie elementy są ujemne: %A na liscie %A, a czy na liscie %A : %A " il liss lisss ili

    printfn "-------------------------------------------------------------------------------"
    printfn "-------------------------------------Klasy-------------------------------------"
    printfn "-------------------------------------------------------------------------------"

    let tr = Trójkąt(3.0,3.0,3.0)
    let polee = tr.ObliczPole()
    printfn "Pole trójkąta o bokach 3,3,3 wynosi: %A " polee

    System.Console.ReadKey() |> ignore
    0 // return an integer exit code