#include <stdio.h>
#include "rand.c"

/****************************************************************/
/* inicializacoes gerais                                        */
/****************************************************************/
#define EPSLON 1E-06

/****************************************************************/
/* prototipos                                                   */
/****************************************************************/
class SConst { // serie globalmente constante
public:
  int tam;
  float *obs;
  float alfa;
  SConst(void): tam(0), obs(0), alfa(0)  {}
  SConst(const SConst &SC);
  virtual float Previsao(int origem, int passFrent);
  virtual float AlfaOtimo(void);
};

float SQE(SConst *SC);

/****************************************************************/
/* implementacoes                                               */
/****************************************************************/
SConst::SConst(const SConst &SC) {
  tam = SC.tam;
  obs = new float[tam];
  for (int i=0; i<tam; i++) 
      obs[i] = SC.obs[i];
  alfa = SC.alfa;
}

float SConst::Previsao(int origem, int passFrent) {
  float prev = 0.0;
  for (int i=origem; i>=0; i--) {
     prev += alfa*pow((1-alfa),origem-i)*obs[i]; 
  }
//  fprintf(stdout, "SConst::Previsao(%d,%d): %f\n", origem, passFrent, prev);
  return prev;
}

float SConst::AlfaOtimo(void) {
  // otimizar o alfa pelo metodo da Secao Aurea
  const float F = (sqrt(5) - 1)/2;
  float a, b, v, g_v, w, g_w, otimo;
  a = 0.0;
  b = 1.0;
  v = b - F*(b-a);
  alfa = v;
  g_v = SQE(this);
//  fprintf(stdout, "SConst::AlfaOtimo: g_v(%f) = %f\n", v, g_v);
  w = a + F*(b-a);
  alfa = w;
  g_w = SQE(this);
//  fprintf(stdout, "SConst::AlfaOtimo: g_w(%f) = %f\n", w, g_w);
  while ( F * (b-a) > EPSLON )
        if ( g_v < g_w ) {
           b = w; 
           w = v; 
           g_w = g_v; 
           v = b - F*(b-a);
           alfa = v;
           g_v = SQE(this);
//           fprintf(stdout, "SConst::AlfaOtimo: g_v(%f) = %f\n", v, g_v);
        } else {
           a = v; 
           v = w; 
           g_v = g_w; 
           w = a + F*(b-a);
           alfa = w;
           g_w = SQE(this);
//           fprintf(stdout, "SConst::AlfaOtimo: g_w(%f) = %f\n", w, g_w);
        }
  if ( g_v < g_w )
     otimo = w;
  else
     otimo = v;
//  fprintf(stdout, "SConst::AlfaOtimo: otimo = %f\n", otimo);
  return otimo;
}
      
float SQE(SConst *SC) {
  float sqe = 0.0;
  int passFrent = 1;
  for (int i = 0; i < SC->tam-1; i++) {
      sqe += pow( (SC->Previsao(i, passFrent) - SC->obs[i+1]), 2);
//      fprintf(stdout, "SQE: (previsao (%f) - observacao(%f))^2 = %f\n",
//              SC->Previsao(i, passFrent), SC->obs[i+1],
//              pow((SC->Previsao(i, passFrent) - SC->obs[i+1]),2) );
//      fprintf(stdout, "SQE: sqe = %f\n", sqe);
  }
//  fprintf(stdout, "SQE: sqe = %f\n", sqe);
  return sqe;
}      
  
int main(void) {
    SConst aSerieC;
    int sement = 0;

    //  simular uma serie globalmente constante de tamanho TAM
    const int TAM = 10;
    aSerieC.tam = TAM;
    aSerieC.obs = new float[aSerieC.tam];
    for (int i=0; i<aSerieC.tam; i++) {
        aSerieC.obs[i] = urand(&sement);
    }

    //  achar alfa que minimiza erro quadratico das previsoes 1 passo frente
    fprintf(stdout, "A serie\n");
    for (int i=0; i<aSerieC.tam; i++) {
        fprintf(stdout, "%f\n", aSerieC.obs[i]);
    }
    fprintf(stdout, "tem alfa que minimiza o SQE igual a %f\n", 
            aSerieC.AlfaOtimo() );
}