public void addDependiente(Atributo attr = null,bool enlazar = false)
 {
     if (!this.determina.Contains(attr)) {
         if (enlazar) attr.addDeterminante(this);
         this.determina.Add(attr);
     }
 }
 public void addDeterminante(Atributo attr)
 {
     if (!this.depende.Contains(attr)) {
         attr.addDependiente(this);
         this.depende.Add(attr);
     }
 }
 private void nuevoToolStripMenuItem_Click(object sender, EventArgs e)
 {
     mapaAtributos.Clear();
     clavePrimaria = null;
     fmas.Clear();
     normal.Clear();
     listaDependencias.Items.Clear();
     listaRelaciones.Items.Clear();
     clavesCandidatas.Clear();
     tf_entrada.Clear();
     cb_tipo.SelectedIndex = 0;
     cb_accion.SelectedIndex = 0;
     cb_tipo.Enabled = false;
     cb_accion.Enabled = false;
     btn_ejecutar.Enabled = false;
     etiqueta_estado.Text = "Esperando relacion...";
 }
 private bool estaEnTablas(List<Tabla> tablas,Atributo attr)
 {
     foreach (Tabla tabla in tablas) {
         //if (xSubY(attr, tabla.getClavePrimaria())) return true;
         if (tabla.getColumnas().Contains(attr)) return true;
     }
     return false;
 }
 private bool estaEnTabla3FN(Atributo attr)
 {
     return estaEnTablas(TERCERAFN, attr);
 }
 private bool estaEnTabla2FN(Atributo attr)
 {
     return estaEnTablas(SEGUNDAFN, attr);
 }
 private List<Atributo> determinatesPorTransitividad(Atributo attr)
 {
     return determinatesPorTransitividad(attr, new List<Atributo>());
 }
 public bool contains(Atributo attr)
 {
     return this.columnas.Contains(attr);
 }
 /*  cumple3FN
  *  Todo atributo que dependa transitivamente de la ClavePrimaria
  *  No cumple la 3FN
  */
 private bool cumple3FN(Atributo attr, Tabla tabla)
 {
     /* Si existe algun Atributo X que determine a Y, que no pertenezca a la clavePrimaria
      * Decimos que Y depende transitivamente de la clavePrimaria.
      */
     foreach (Atributo at in attr.getDeterminantes()) {
         if (tabla.contains(at)) return false;
     }
     return true;
 }
 //=========================================================================
 /* cumple2FN
  * 1. Todo atributo no primo de la relacion debe depender de la clave primaria
  * 2. Todo atributo que dependa parcialmente de la clavePrimaria no cumple 2FN
  */
 private bool cumple2FN(Atributo attr, Atributo pk)
 {
     /*Si algun Atributo X que Determine a Y, es Subconjunto de la ClavePrimaria
      * Decimos que Y depende parcialmente de la Clave Primaria
      * entonces no cumple la 2FN
      */
     foreach (Atributo at in attr.getDeterminantes()) {
         if (xSubY(at, pk)) return false;
     }
     return true;
 }
        private void crearConjuntos()
        {
            int cantidadOriginales = mapaAtributos.Count;
            List<KString> unitarios = new List<KString>();
            /*TODOS*/
            String nuevo = "";
            foreach (var key in mapaAtributos.Keys) {
                Atributo attr = mapaAtributos[key];
                if (!attr.esConjunto() && !attr.esMultivaluado()) {
                    nuevo += (nuevo == "") ? attr.getValor().value() : "," + attr.getValor();
                    unitarios.Add(attr.getValor());
                }
            }

            Atributo atributoConj = new Atributo(nuevo);
            if (!mapaAtributos.ContainsKey(atributoConj.getValor())) {
                mapaAtributos.Add(atributoConj.getValor(), atributoConj);
                System.Diagnostics.Debug.WriteLine("Agregado: " + nuevo);
            }

            /*Subconjuntos pequeños*/

            KString TODOS = new KString(nuevo);
            for (int i = 2; i < cantidadOriginales - 1; i++) {
                List<KString> nuevos = combinacion(unitarios, i);
                foreach (KString nuevoCon in nuevos) {
                    if (!mapaAtributos.ContainsKey(nuevoCon)) {
                        mapaAtributos.Add(nuevoCon, new Atributo(nuevoCon));
                    }
                }
            }
            /*
            List<String> nuevos = new List<String>();
            foreach (var atributoAQuitar in mapaAtributos.Keys) {
                nuevo = "";
                foreach (var key in mapaAtributos.Keys) {
                    if (atributoAQuitar == key) continue;
                    Atributo attr = mapaAtributos[key];
                    if (!attr.esConjunto() && !attr.esMultivaluado()) {
                        nuevo += (nuevo == "") ? attr.getValor().value() : "," + attr.getValor();
                    }
                }
                nuevos.Add(nuevo);
            }

            foreach (String val in nuevos) {
                Atributo atributoSubConj = new Atributo(val);
                if (!mapaAtributos.ContainsKey(atributoSubConj.getValor())) {
                    mapaAtributos.Add(atributoSubConj.getValor(), atributoSubConj);
                    System.Diagnostics.Debug.WriteLine("Agregado: " + val);
                }
            }*/
        }
 private Atributo calculaSubPK(Atributo attr, Atributo pk)
 {
     foreach (Atributo at in attr.getDeterminantes()) {
         if (xSubY(at, pk)) return at;
     }
     return null;
 }
 private Atributo calcularFK(Atributo attr, Tabla tabla)
 {
     foreach (Atributo at in attr.getDeterminantes()) {
         if (tabla.contains(at)) return at;
     }
     return null;
 }
        private void button1_Click_1(object sender, EventArgs e)
        {
            String entrada = tf_entrada.Text.ToUpper();
            switch (cb_tipo.SelectedIndex) {
                //Agregar Relacion
                case 0: {
                    if (relacionValida(entrada)) {
                        listaRelaciones.Items.Add(entrada);
                        String[] elementos = entrada.Split(',');
                        confPB(elementos.Length);
                        foreach (String elem in elementos) {
                            Atributo attr = new Atributo(elem);
                            mapaAtributos.Add(attr.getValor(), attr);
                            barra_progreso.PerformStep();
                        }
                        crearConjuntos();
                        barra_progreso.Value = 0;
                        cb_tipo.SelectedIndex = 1;
                        tf_entrada.Text = "";
                        etiqueta_estado.Text = "Esperando Dependencia...";
                    } else {
                        MessageBox.Show("Datos invalidos, porfavor revise: "+entrada+"\nFormato válido: X,Y<m>,Z,W<m>");
                    }
                        break;
                    }
                //Agregar Dependencia
                case 1: {
                        if (dependenciaValida(entrada)) {
                            String[] deps = entrada.Split('/');
                            foreach (String entradaD in deps) {
                                listaDependencias.Items.Add(entradaD);
                                String[] partes = entradaD.Split('>');
                                KString determinantes = new KString(partes[0]);
                                KString dependientes = new KString(partes[1]);

                                Atributo attrDeterminate;
                                Atributo attrDependiente;
                                if (mapaAtributos.ContainsKey(determinantes)) {
                                    attrDeterminate = mapaAtributos[determinantes];
                                } else {
                                    attrDeterminate = new Atributo(determinantes);
                                    mapaAtributos.Add(determinantes, attrDeterminate);
                                }
                                if (mapaAtributos.ContainsKey(dependientes)) {
                                    attrDependiente = mapaAtributos[dependientes];
                                } else {
                                    attrDependiente = new Atributo(dependientes);
                                    mapaAtributos.Add(dependientes, attrDependiente);
                                }
                                /*al agregar un determinante a un atributo internamente
                                 se agrega al atributo como dependiente.
                                 */
                                attrDependiente.addDeterminante(attrDeterminate);
                            }
                            tf_entrada.Text = "";
                            etiqueta_estado.Text = "Listo";
                            btn_ejecutar.Enabled = true;
                        } else {
                            MessageBox.Show("Datos invalidos, porfavor revise: " + entrada + "\nFormato válido: X,Y>W,Z[/Q,P>R,S]");
                        }
                        break;
                    }
            }//FIn Switch
        }
 public void setClavePrimaria(Atributo PK)
 {
     this.clavePrimaria = PK;
 }
 private Tabla tabla3FNConPK(Atributo pk)
 {
     foreach (Tabla tabla in TERCERAFN) {
         if (tabla.getClavePrimaria() == pk) return tabla;
     }
     return null;
 }
 /*Determina si x es subconjunto de y
  *
  */
 private bool xSubY(Atributo x, Atributo y)
 {
     KString[] conjX = x.getAtributosDelConjunto();
     KString[] conjY = y.getAtributosDelConjunto();
     //Si |x| >= |y|, x no puede ser subconjunto de y
     if (conjX.Count() >= conjY.Count()) return false;
     //Si Y no contiene alguno de los elementos de X, X no es subconjunto de Y
     foreach (KString elem in conjX) {
         if (!conjY.Contains(elem)) return false;
     }
     return true;
 }
        private void determinarClavePrimaria()
        {
            if (clavesCandidatas.Count <= 0) {
                MessageBox.Show("No se han encontrado Claves Candidatas ni clave primaria!\nNo se puede normalizar!");
                return;
            }
            cb_accion.Enabled = true;
            cb_accion.SelectedIndex = 1;

            int menor = clavesCandidatas.First().Value.getPeso();
            KString kmenor = clavesCandidatas.First().Key;
            if (menor > 1) {
                foreach(var key in clavesCandidatas.Keys){
                    Atributo kcand = clavesCandidatas[key];
                    if (kcand.getPeso() < menor) {
                        menor = kcand.getPeso();
                        kmenor = (KString)key;
                    }
                }
            }
            clavePrimaria = clavesCandidatas[kmenor];
            fmas.Text += "Clave Primaria: " + clavePrimaria.getValor() + " \n";
        }
 /*  determinatesPorTransitividad(Atributo attr)
  *  attr: Atributo del cual se quiren conseguir los Atributos que lo determinan
  *  retorna todos los Atributos que determinan a 'attr'
  *  *Es Recursivo, tomando la dependencia A>B>C>D, el metodo va 'escalando' desde D hasta A
  *  Tomando cada uno de sus determinantes.
  */
 private List<Atributo> determinatesPorTransitividad(Atributo attr,List<Atributo> attrAnalizados)
 {
     List<Atributo> todos = new List<Atributo>();
     todos = todos.Concat(attr.getDeterminantes()).ToList();
     attrAnalizados.Add(attr);
     foreach (Atributo det in attr.getDeterminantes()) {
         if (attrAnalizados.Contains(det)) continue;
         todos = todos.Concat(determinatesPorTransitividad(det, attrAnalizados)).ToList();
     }
     return todos;
 }
 public void addColumna(Atributo attr)
 {
     columnas.Add(attr);
 }