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

exception N_Mniejsze_Od_Zera

let rec silnia n =
    match n with
    | nn when n < 0 -> raise N_Mniejsze_Od_Zera ///Dodano wyszucenie wyjątku
    | 0 -> 1
    | _ -> n * silnia( n-1)

let rec adob ( a, b ) =
    match b with
    | nn when b < 0 -> raise N_Mniejsze_Od_Zera
    | 0 -> 1
    | _ -> a * adob(a, b-1)

let rec fibo n =
    match n with
    | 0 -> 1
    | 1 -> 1
    | _ -> fibo( n-1) + fibo (n-2)

let rec mRn ( m, n) =
    match n with
    | 0 -> m*0
    | 1 -> m*1
    | _ -> m + mRn (m,n-1)

let niePodzielny (d,n) =
    let nn = d % n
    match nn with
    | 0 -> true
    | _ -> false

let liczWyst (str: string , znak: char ) =
    let dl = String.length str
    let ilosc = ref 0
    for i = 0 to  dl - 1 do
        if str.[i] = znak then incr(ilosc)
    ilosc.Value

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

let pow (str: string, n: int) =
    match n with
    | 0 -> "error"
    | 1 -> str
    | _ -> String.replicate(n) str

let rec NWD (m,n) =
    match n with
    | 0 -> abs(m)
    | _ -> NWD (n, m%n)

exception DzieleniePrzezZero

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

let ( -- ) (a,b)(c,d)=
    if b*d = 0 then raise DzieleniePrzezZero
    else  a*d - b*c, 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

let skróc (a:int ,b: int) =
    let znak = if a*b < 0 then -1 else  1
    let ll = abs a
    let mm = abs b
    let dzielnik = NWD(ll, mm)
    let licznik = ll / dzielnik
    let mianownik = mm / dzielnik
    znak * licznik , mianownik

let naString(a , b) =
    let znak = if a*b < 0 then "-" else  ""
    let licz, mian = skróc(abs(a),abs(b))
    let calk = licz / mian
    let licznik = licz - calk*mian
    let calkowita = if calk > 0 then calk.ToString() else ""
    let ulamek = if licznik > 0 then " " + licznik.ToString() + "/" + mian.ToString() else ""
    znak + calkowita + ulamek

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

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

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

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

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

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

let mnul (liczba : int, licz : int, mian: int) =
    liczba * licz , mian

let dzielul (liczba : int, licz : int, mian: int) =
    licz, mian * liczba

let pierul (licz : float, mian: float) =
    sqrt(licz),sqrt (mian)

let odrul (licz : int, mian: int) =
    mian, licz

type Student = {imie: string; nazwisko: string; indeks: int}

let SprawdzStudenty (stud1:Student list) =
    let dl1 = stud1.Length
    let ilosc = ref(0)

    for i = 0 to dl1 - 1 do
        for k = 0 to dl1 - 1 do
            if stud1.[i].nazwisko = stud1.[k].nazwisko then incr(ilosc)

    if ilosc.Value > dl1 then true else false

    //--------------------LISTY

let minlist lista =
    List.min lista

let dllist lista =
    List.length lista

let krotnosc (x:int , lista: int list) =
    let ilosc = ref(0)
    List.iter(fun a -> if a = x then incr(ilosc)) lista
    ilosc.Value

let ntyel (kt, lista) =
    let dl = List.length lista
    if kt < dl then
        lista.[kt]
    else
        0

let czyujemne lista =
    let ileuj = ref(0)
    List.iter(fun x -> if x < 0 then incr(ileuj)) lista
    if ileuj.Value = lista.Length then true else false   // Tu był błąd, sprawdza funkcja czy wzystkie mają być nie ujemne

let minmax lista =
    List.min lista , List.max lista



///////ZADANIA Z ZALICZENIA L7///////////////////////////


let rec len'(x:list<int>,y:int):int= //funkcja pomocnicza do funkcji nizej
    match x with
    | x1 :: x -> len'(x,y+1)
    | x -> y

let len x = //własna implementacja funkcji lenght do listy
    len'(x,0)


[<AbstractClass>]
type figura (P) =
    inherit Object()
    let mutable Pole:float = 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 //połowa obwodu
        base.pole<- sqrt(abs(p*(p-a)*(p-b)*(p-c))) // wzór Herona
        base.pole


[<EntryPoint>]
let main argv =
    //let sil = silnia(-2)
    let nn = (1,4) ++ (3,4)
    let nnn = naString(-16 , 16)
    let zesp = (2,3) /././ (4,-4)
    let pierw = pierwsza 11

    let Zdziszek = {imie = "Zdzisław"; nazwisko = "Zdziwiony"; indeks = 23167}
    let Zbyszek = {imie = "Zbyszek"; nazwisko =  "Szwagrowski"; indeks = 123212 }
    let Marian = {imie = "Marian"; nazwisko = "Trzeci"; indeks = 333333 }

    let Studenty = [Zdziszek ; Zbyszek ; Marian]

    let czy = SprawdzStudenty Studenty

    //--------------------LISTY
    let calk = [5;3;6;8;10;5]
    let mini = minlist calk //1
    let dllisty = dllist calk //2
    let kr = krotnosc(4,calk) //3
    let nelement = ntyel(3,calk)//4
    let czyuj= czyujemne calk //5
    let min,max = minmax calk //6


    let aaaa = trójkąt(3.0,3.0,3.0)
    let p2=aaaa.ObliczPole()
    let P = (3.0*3.0 * sqrt(3.0))/4.0 //test czy wzór herona działa, na przykładzie trójkąta równopocznego


    let cc = [1;2;3;4;5;6;7;8]
    let dlll = len(cc)

    printfn "%A %A %A" <| p2  <| P <| aaaa.pole
    System.Console.ReadKey() |> ignore
    0 // return an integer exit code