//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
/** @author  John Miller
 *  @version 1.6
 *  @date    Sat Jun 13 01:27:00 EST 2017
 *  @see     LICENSE (MIT style license file).
 *
 *  @title   Test: Economics Domain
 */

package scalation.analytics
package forecaster

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

import ActivationFun._

//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
/** The `ExampleEcon` object tests various prediction and forecasting techniques
 *  on daily economic/finance time-series data.
 *  > runMain scalation.analytics.forecaster.ExampleEcon
 */
object ExampleEcon extends App
{
    val MISSING = -999999                                   // misiing value

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

    Clean.setMissing ()
    var xy = Clean.clean (xyr)
    val _1 = VectorD.one (xy.dim1)                          // column of all ones

    for (j <- xy.range2) {
        banner (s"column $j")
        val y  = 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

    // forecast column 8 using columns 19 to 33 (first column is column 0)

    xy = xy.slice (0, 200)                                  // comment out for all rows
    println (s"xy.dim1 = ${xy.dim1}, xy.dim2 = ${xy.dim2}")
    val y = xy.col (8)
    val x = xy.sliceCol (19, 26)
//  val x = xy.sliceCol (19, xy.dim2)
    println (s"x.dim1 = ${x.dim1}, x.dim2 = ${x.dim2}")

    val rescaled = false

/*
    banner ("Regression - no intercept")
    val rg = if (rescaled) Regression (x, y, null, null, RegTechnique.QR)
             else      new Regression (x, y)
    rg.train ().eval ()
    println (rg.report)
//  println (rg.summary)

    banner ("Regression")
    val rg2 = if (rescaled) Regression (_1 +^: x, y, null, null, RegTechnique.QR)
              else      new Regression (_1 +^: x, y)
    rg2.train ().eval ()
    println (rg2.report)
//  println (rg2.summary)

    banner ("QuadRegression")
    val rg3 = if (rescaled) QuadRegression (x, y, null, null, RegTechnique.QR)
              else      new QuadRegression (x, y)
    rg3.train ().eval ()
    println (rg3.report)
//  println (rg3.summary)

    banner ("QuadXRegression")
    val rg4 = if (rescaled) QuadXRegression (x, y, null, null, RegTechnique.QR)
              else      new QuadXRegression (x, y)
    rg4.train ().eval ()
    println (rg4.report)
//  println (rg4.summary)

    banner ("CubicRegression")
    val rg5 = if (rescaled) CubicRegression (x, y, null, null, RegTechnique.QR)
              else      new CubicRegression (x, y)
    rg5.train ().eval ()
    println (rg5.report)
//  println (rg5.summary)

    banner ("CubicXRegression")
    val rg6 = if (rescaled) CubicXRegression (x, y, null, null, RegTechnique.QR)
              else      new CubicXRegression (x, y)
    rg6.train ().eval ()
    println (rg6.report)
//  println (rg6.summary)
*/

    for (l <- 2 to 6) {
        banner (s"Regression4TS - until lag $l")
        val hp2 = Regression4TS.hp.updateReturn (("lag1", 1.0), ("lag2", l.toDouble))
        val rg7 = if (rescaled) Regression4TS (x, y, null, hp2, RegTechnique.QR)
                  else      new Regression4TS (x, y)
        rg7.train ().eval ()
        println (rg7.report)
    //  println (rg7.summary)
        rg7.crossVal ()
    } // for
/*

    for (l <- 2 to 6) {
        banner (s"QuadRegression4TS - until lag $l")
        val hp2 = Regression4TS.hp.updateReturn (("lag1", 1.0), ("lag2", l.toDouble))
        val rg7b = if (rescaled) QuadRegression4TS (x, y, null, hp2, RegTechnique.QR)
               else      new QuadRegression4TS (x, y)
        rg7b.train ().eval ()
        println (rg7b.report)
    //  println (rg7b.summary)
    } // for

    for (l <- 2 to 6) {
        banner (s"QuadXRegression4TS - until lag $l")
        val hp2 = Regression4TS.hp.updateReturn (("lag1", 1.0), ("lag2", l.toDouble))
        val rg7c = if (rescaled) QuadXRegression4TS (x, y, null, hp2, RegTechnique.QR)
                   else      new QuadXRegression4TS (x, y)
        rg7c.train ().eval ()
        println (rg7c.report)
    //  println (rg7c.summary)
    } // for

    banner ("ELM_3L1: no intercept")
    val rg8 = if (rescaled) ELM_3L1 (x, y, 2 * x.dim2 + 1, null, null, f_tanh)
              else      new ELM_3L1 (x, y)
    rg8.train ().eval ()
    println (rg8.report)
//  println (rg8.summary)

    for (s <- 10 to 11) {
        banner ("ELM_3L1")
        val rg9 = if (rescaled) ELM_3L1 (_1 +^: x, y, s * x.dim2 + 1, null, null, f_tanh)
                  else      new ELM_3L1 (_1 +^: x, y, s * x.dim2 + 1)
        rg9.train ().eval ()
        println (rg9.report)
//      println (rg9.summary)
    } // for

    banner ("NeuralNet_3L")
    val nz = x.dim2 + 1
//    val rg9 = NeuralNet_3L (x, y, nz, null, null, f_sigmoid, f_id)
    val rg9 = NeuralNet_3L (x, y, nz, null, null, f_tanh, f_id)
      NeuralNet_3L.rescaleOff ()
//    val hp2 = Optimizer.hp.updateReturn (("eta", 0.02))
//    val rg9 = NeuralNet_3L (x, y, nz, null, hp2, f_lreLU, f_id)
//    val rg9 = NeuralNet_3L (x, y, nz, null, null, f_eLU, f_id)
    rg9.train2 ().eval ()
    println (rg9.report)
//  println (rg9.summary)

    banner ("model prices instead of rates")
    val yp = rg6.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)
*/

} // ExampleEcon object