package university.projects.ioimov6laba

import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import java.lang.Math.sqrt
import kotlin.math.abs
import kotlin.math.pow
import kotlin.math.sqrt

class MainActivity : AppCompatActivity() {

    //step 1
    private val l = 0.01
    private val e = 0.001
    private val Ъ = 0.001
    private var k = 0
    private var lk = 0.1
    private var a: MutableList<Double> = mutableListOf()
    private var b: MutableList<Double> = mutableListOf()
    private var yk: MutableList<Double> = mutableListOf()
    private var zk: MutableList<Double> = mutableListOf()
    private var x: MutableList<Double> = mutableListOf()
    private var deltaX = 1

    private fun init() {
        k = 0
        lk = 0.1
        a = mutableListOf()
        b = mutableListOf()
        yk = mutableListOf()
        zk = mutableListOf()
        x = mutableListOf()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val goldenSectionMethodSolution = goldenSectionMethod()
        val halfDivisionSolution = halfDivision()
        val polynomialSolution = polynomialApproximation()
        val newton = newton()
        val bolzman = bolzman()
        hashCode()
    }

    private fun bolzman(): Double {
        fun getZk(ak: Double, bk: Double): Double {
            return (ak + bk) / 2
        }

        fun derivativeFx(x: Double): Double {
            return 4 * x.pow(3) - 30 * x.pow(2) + 72 * x + 5
        }
        init()
        k = 0
        a.add(3.0)
        b.add(5.0)
        do {
            val zk = getZk(a[k], b[k])
            this.zk.add(zk)
            val derivativeFzk = derivativeFx(this.zk[k])
            if (derivativeFzk < 0) {
                a.add(this.zk[k])
                b.add(b[k])
            } else if (derivativeFzk > 0) {
                a.add(a[k])
                b.add(this.zk[k])
            }
            if (Math.abs(derivativeFzk) <= e + a[0]) {
                return this.zk[k]
            }
            if(b[k] == a[0]){
                return this.zk[k]
            }
            k++
            Log.e("bolzman", b.toString())
        }while (Math.abs(derivativeFx(this.zk.last())) > e)

        return 0.0
    }

    private fun f(x: Double): Double {
        return x.pow(4) - 10 * x.pow(3) + 36 * x.pow(2) + 5 * x
    }

    private fun newton(): Double {
        fun derivativeFx(x: Double): Double {
            return 4 * x.pow(3) - 30 * x.pow(2) + 72 * x + 5
        }

        fun doubleDerivativeFx(x: Double): Double {
            return 12 * x.pow(2) - 60 * x + 72
        }

        init()
        var n = 0
        x.add(0.0)

        var o: Double

        do {
            val xnplusone = x[n] - (derivativeFx(x[n]) / doubleDerivativeFx(x[n]))
            x.add(xnplusone)

            if (Math.abs(derivativeFx(x[n + 1])) <= e) {
                if (x[n + 1] < x[0])
                    return 3.0
            } else {
                n++
            }
        } while (Math.abs(derivativeFx(x.last())) > e)

        return 0.0
    }

    private fun polynomialApproximation(): Double {
        fun findA1(x2: Double, x1: Double): Double {
            return (f(x2) - f(x1)) / (x2 - x1)
        }

        fun findA2(): Double {
            return (1 / (x[2] - x[1])) * (findA1(x[2], x[0]) - findA1(x[1], x[0]))
        }

        fun findNotX(a1: Double, a2: Double): Double {
            return ((x[1] + x[0]) / 2) - (a1 / (2 * a2))
        }
        init()
        var firstCheck: Boolean
        var secondCheck: Boolean
        x.add(0.0)
        val t = mutableListOf<Double>()

        x.add(x[0] + deltaX)
        val fx1 = f(x[0])
        val fx2 = f(x[1])
        if (fx1 > fx2) {
            x.add(x[0] + 2 * deltaX)
        } else {
            x.add(x[0] - deltaX)
        }

        if (x[2] < x[0]) {
            val x1 = x[0]
            val x2 = x[1]
            val x3 = x[2]
            x[0] = x3
            x[1] = x1
            x[2] = x2
        }

        do {
            val fMin = x.map { x -> f(x) }.min()
            val xMin = x[x.map { x -> f(x) }.indexOf(fMin)]
            val a1 = findA1(x[1], x[0])
            val a2 = findA2()
            val notX = findNotX(a1, a2)

            firstCheck = (Math.abs(fMin!! - f(notX)) <= e)
            secondCheck = Math.abs(xMin - notX) <= Ъ

            if (firstCheck && secondCheck) {

                return if (notX <3.0){
                    3.0
                } else{
                    notX
                }
            } else {
                val best = if (f(notX) < fMin) {
                    notX
                } else {
                    xMin
                }
                t.addAll(x)
                t.add(notX)
                t.add(best)
                t.sort()
                val index = t.indexOf(best)

                x[0] = t.first { x -> x < best }
                x[1] = best
                x[2] = t.first { x -> x > best }

            }
        } while (!(firstCheck && secondCheck))
        return 0.0
    }

    private fun halfDivision(): Double {
        fun findYk(k: Int): Double {
            return (a[k] + b[k] - e) / 2
        }

        fun findZk(k: Int): Double {
            return (a[k] + b[k] + e) / 2
        }
        init()

        a.add(3.0)
        b.add(5.0)
        k = 0
        while (lk > l) {
            yk.add(findYk(k))
            zk.add(findZk(k))

            val fyk = f(yk[k])
            val fzk = f(zk[k])

            if (fyk <= fzk) {
                a.add(a[k])
                b.add(zk[k])
            } else {
                a.add(yk[k])
                b.add(b[k])
            }
            lk = Math.abs(b[k + 1] - a[k + 1])
            if (lk <= l) {
                return (a[k + 1] + b[k + 1]) / 2
            } else {
                k += 1
            }
        }
        return 0.0
    }

    private fun goldenSectionMethod(): Double {
        fun findYk(k: Int): Double {
            return a[k] + ((3 - sqrt(5.0)) / 2) * (b[k] - a[k])
        }

        fun findZk(y0: Double, k: Int): Double {
            return a[k] + b[k] - y0
        }

        init()

        a.add(3.0)
        b.add(5.0)

        //step 3
        val yk = findYk(k)
        this.yk.add(yk)
        val zk = findZk(yk, k)
        this.zk.add(zk)
        //step 4
        while (lk > l) {
            val fyk = f(this.yk[k])
            val fzk = f(this.zk[k])
            //step 5
            if (fyk <= fzk) {
                a.add(a[k])
                b.add(this.zk[k])
                this.yk.add(findZk(this.yk[k], k + 1))
                this.zk.add(this.yk[k])
            } else {
                a.add(this.yk[k])
                b.add(b[k])
                this.yk.add(zk)
                this.zk.add(findZk(zk, k + 1))
            }
            //step 6
            lk = abs(b[k + 1] - a[k + 1])
            if (lk <= l) {
                return (a[k + 1] + b[k + 1]) / 2
            } else {
                k += 1
                Log.e("continue", k.toString())
            }
        }

        return 0.0
    }
}