// use Neural Net, code sMAPE

package scalation.analytics
package forecaster

import scalation.⁄ 
import scalation.linalgebra.{MatrixD, VectoD, VectorD}
import scalation.math.noDouble
import scalation.util.banner

//import Clean.clean

// > runMain scalation.analytics.forecaster.Econ

object Econ extends App
{
    val MISSING = -999999

    val xyr = MatrixD (BASE_DIR + "RESEARCH_DATA.csv", 1)
    println (s"xy.dim1 = ${xy.dim1}, xy.dim2 = ${xy.dim2}")

    val xy = Clean.clean (xyr)

    def clean (y: VectorD): VectoD =
    {
        val yf = y.filter (_ != MISSING)
        val y_mu = yf.mean
        for (i <- y.range if y(i) == MISSING) y(i) = y_mu
        y
    } // clean

    for (j <- xy.range2) {
        banner (s"column $j")
        val y  = clean (xy.col (j))
        println (s"ymean = ${y.mean}, ymin = ${y.min()}, ymax = ${y.max()}")

        for (i <- y.range if y(i) == MISSING) println (s"i = $i, y(i) = ${y(i)}}")
        for (i <- y.dim - 5 until y.dim) println (s"i = $i, y(i) = ${y(i)}}")
    } // for

    // predict column 7 using columns 14-24
    // predict column 8 using columns 14-24

    val y = clean (xy.col (7))
    val x14 = clean (xy.col (14))
    val x15 = clean (xy.col (15))
    val x16 = clean (xy.col (16))
    val x17 = clean (xy.col (17))
    val x18 = clean (xy.col (18))
    val x19 = clean (xy.col (19))
    val x20 = clean (xy.col (20))
    val x21 = clean (xy.col (21))
    val x22 = clean (xy.col (22))
    val x23 = clean (xy.col (23))
    val x24 = clean (xy.col (24))
    val x = MatrixD (Seq (x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24))

/*
    val x36 = clean (xy.col (36))
    val x37 = clean (xy.col (37))
    val x38 = clean (xy.col (38))
    val x39 = clean (xy.col (39))
    val x = MatrixD (Seq  (x36, x37, x38, x39))

    val x40 = clean (xy.col (40))
    val x41 = clean (xy.col (41))
    val x42 = clean (xy.col (42))
    val x43 = clean (xy.col (43))
    val x44 = clean (xy.col (44))
    val x45 = clean (xy.col (45))
    val x = MatrixD (Seq  (x40, x41, x42, x43, x44, x45))

    val x46 = clean (xy.col (46))
    val x = MatrixD (Seq  (x46))
*/

    banner ("Regression")
    val rg = new Regression (x,y)
    rg.train ().eval ()
    println (rg.report)
    println (rg.summary)
    
    banner ("QuadRegression")
    val rg2 = new QuadRegression (x, y)
    rg2.train ().eval ()
    println (rg2.report)
    println (rg2.summary)

    banner ("ResponseSurface")
    val rg3 = new ResponseSurface (x, y)
    rg3.train ().eval ()
    println (rg3.report)
    println (rg3.summary)

    banner ("ELM_3L1")
    val rg4 = new ELM_3L1 (x, y)
    rg4.train ().eval ()
    println (rg4.report)
    println (rg4.summary)

    banner ("model prices instead of rates")
    val yp = rg3.predict ()
    val pr = new VectorD (y.dim); pr(0) = 1.0
    for (i <- 1 until y.dim) pr(i) = pr(i-1) * (1 + 0.01 * y(i-1)) 
    val pr2 = new VectorD (y.dim); pr2(0) = 1.0
    for (i <- 1 until y.dim) pr2(i) = pr2(i-1) * (1 + 0.01 * yp(i-1)) 

    val rg33 = SimpleRegression (pr, pr2)
    rg33.train ().eval ()
    println (rg33.report)

} // Econ object