// Mon Mar 20 15:31:21 CET 2000
// programa de aprendizaje                                 */
// lun may  8 18:34:06 CEST 2006 
// ramas entrelazadas

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "entropia.h"
#include "tabla2.h"
#include "arbid.h"

float entrFun (f, b, nlt)
int * f;
int * * b;
int nlt;
{
  int c0, c1;
  int l;
  c0 = c1 = 0;
  for (l=0; l<nlt; l++)
    if (f[l]) c1++ ;
    else c0++;
  return entropia (c0, c1);
}

float entrColNiv (f, b, nlt, col, niv)
int * f;
int * * b;
int nlt;
int col, niv;
{
  int c00, c01, c10, c11;
  cuentaColNiv (f, b, nlt, col, niv, &c00, &c01, &c10, &c11);
  return entropia (c00, c01) + entropia (c10, c11) ;
}

int nivOpt2 (int *f, int ** b, int nlt, int col, float *pentmn)
{
  int nv, nvo;
  int cv0[257], cv1[257];
  int tot0, tot1;
  float ent, entmin;
  cuentaColNiveles (f, b, nlt, col, cv0, cv1);
  // en cv0[n]  cuantos f==0  variable == n
  for (nv=tmn[col]; nv<tmx[col]; nv++){
    cv0 [nv+1] += cv0 [nv];
    cv1 [nv+1] += cv1 [nv];
    }
  // en cv0[n]  cuantos f==0  variable <= n
  tot0 = cv0 [tmx[col]];
  tot1 = cv1 [tmx[col]];
  nvo = nv = tmn[col];
  entmin = entropia (tot0, tot1);
  for (nv=tmn[col]+1; nv<=tmx[col]; nv++){
    ent = entropia (cv0[nv-1], cv1[nv-1]) +
          entropia (tot0 - cv0[nv-1], tot1 - cv1[nv-1])  ;
    if (ent < entmin){
      nvo = nv;
      entmin = ent;
      }
    // printf ("%d entropia: %8.4f\n", nv, ent) ;
    }
  *pentmn = entmin;
  return nvo;
}

// toma el CENTRO de un intervalo plano de entropia minima
int nivOpt3 (int *f, int ** b, int nlt, int col, float *pentmn)
{
  int nv, nvo, nvo1, nvo2;
  int cv0[257], cv1[257];
  int tot0, tot1;
  float ent, entmin;
  cuentaColNiveles (f, b, nlt, col, cv0, cv1);
  // en cv0[n]  cuantos f==0  variable == n
  for (nv=tmn[col]; nv<tmx[col]; nv++){
    cv0 [nv+1] += cv0 [nv];
    cv1 [nv+1] += cv1 [nv];
    }
  // en cv0[n]  cuantos f==0  variable <= n
  tot0 = cv0 [tmx[col]];
  tot1 = cv1 [tmx[col]];
  nvo1 = nv = tmn[col];
  nvo2 = -1;           // extremo superior indefinido
  entmin = entropia (tot0, tot1);
  for (nv=tmn[col]+1; nv<=tmx[col]; nv++){
    ent = entropia (cv0[nv-1], cv1[nv-1]) +
          entropia (tot0 - cv0[nv-1], tot1 - cv1[nv-1])  ;
    if (ent < entmin){
      nvo2 = -1;
      nvo1 = nv;
      entmin = ent;
    }
    if (ent > entmin)
      if (nvo2 == -1) {
        nvo2 = nv-1;
        }
    // printf ("%d entropia: %8.4f\n", nv, ent) ;
    }
  if (nvo2 == -1) {
    nvo2 = tmx[col];
    }
  nvo = (nvo1 + nvo2)/2;
  *pentmn = entmin;
  return nvo;
}

tpnodo colOpt (f, b, m, nlt)
int * f;
int * * b;
int * * m;
int nlt;
{
  int cl, clo;
  int nv, nvo;
  int nlmn, nlmy;
  float ent, entMin;
  float entF;
  int * * c;
  int * * n;
  int * g;
  tpnodo nmn, nmyIg;
  entF = entrFun (f, b, nlt);
  if (entF == 0) {
    if (f[0]){
      // printf (" cierto\n");
      return creaNodo(nd_cierto, 0, 0, NULL, NULL);
      }
    else {
      // printf (" falso\n");
      return creaNodo(nd_falso, 0, 0, NULL, NULL);
      }
    }
  entMin = entF ;
  for (cl=0; cl<nc; cl++){
    // if (masc[cl] == 0) {
    if ( sinMascara(m, nlt, cl) ) {
      nv = nivOpt2 (f, b, nlt, cl, &ent) ; 
      // ent = entrColNiv (f, b, nlt, cl, nv);
      if (ent < entMin){
        clo = cl;
        nvo = nv;
        entMin = ent;
        // printf ("%d %d %8.4f\n", clo, nvo, entMin);
        }
      }
    }
  if (entMin == entF) {
    printf (" no se avanza\n");
    return creaNodo(nd_nose, 0, 0, NULL, NULL);
    }
  c = (int * *) malloc ((size_t) nlt * sizeof(int *));
  n = (int * *) malloc ((size_t) nlt * sizeof(int *));
  g = (int *)   malloc ((size_t) nlt * sizeof(int));
  nlmn = parteMenor (f, g, b, c, m, n, nlt, clo, nvo);
  nmn = colOpt (g, c, n, nlmn);
  nlmy = parteMayorIgual (f, g, b, c, m, n, nlt, clo, nvo);
  nmyIg = colOpt (g, c, n, nlmy);
  // masc2[clo] = 1;
  ponMascara (m, nlt, clo);
  free (c);
  free (g);
  return creaNodo (nd_segun, clo, nvo, nmn, nmyIg) ;
}

tpnodo arbolId3 ()
{
  return colOpt(f, b, masc, nlt);
}