Imprimir este CapítuloImprimir este Capítulo

manual de mi pagina

25. arbol, Manual de Usuario: Diarbol Engine

Manual de Usuario: Diarbol Engine

Diarbol es un ecosistema de visualización y análisis de probabilidad basado en árboles de decisión semánticos. Permite no solo dibujar diagramas, sino también evaluar eventos lógicos complejos mediante una arquitectura de lógica simbólica.

1. Arquitectura del Nodo

Para que el motor funcione, cada nodo debe contener metadatos semánticos más allá de su etiqueta visual:

{
  "nodeLabel": "C",
  "edgeLabel": "Cara",
  "value": 1,
  "tipo": "entero",
  "dominio": "moneda",
  "meta": {
    "origen": "auto"
  }
}
Propiedad Rol
nodeLabel Etiqueta visual dentro del nodo.
edgeLabel Texto visible sobre la rama.
value Valor semántico usado en comparaciones y cálculos.
tipo Tipo del dato: entero, numero, racional o texto.
dominio Contexto del experimento: moneda, dado, urna, ruleta, binario, etc.
meta Información adicional opcional que puede acompañar a la rama.
Importante: si se quiere usar el DSL con sum, eq, gt, lt, gte o lte, cada rama debe llegar al árbol con value bien definido.

2. Referencia de Funciones: DiarbolAuto

El módulo DiarbolAuto es la fachada principal para generar diagramas rápidamente.

Función y descripción Ejemplo de código Resultado visual
dibujarEvento
Renderiza un árbol basado en una estructura root personalizada.		 
DiarbolAuto.dibujarEvento('#vis', {
  root: {
    nodeLabel: 'INI',
    children: [
      { edgeLabel: 'A', nodeLabel: 'A', value: 1, tipo: 'entero', dominio: 'binario' },
      { edgeLabel: 'B', nodeLabel: 'B', value: 0, tipo: 'entero', dominio: 'binario' }
    ]
  }
});
Un nodo inicial con dos ramas definidas manualmente y semántica explícita.
dibujarMoneda
Genera trayectorias equilibradas de lanzamientos de moneda.		 
DiarbolAuto.dibujarMoneda('#vis', {
  lanzamientos: 2,
  theme: 'moneda'
});
Árbol binario simétrico de 4 hojas (C-C, C-S, S-C, S-S) con P = 1/2 en cada rama.
dibujarDado
Genera trayectorias de lanzamientos de dado.		 
DiarbolAuto.dibujarDado('#vis', {
  lanzamientos: 1
});
Un nodo inicial con 6 ramificaciones numeradas y probabilidad P = 1/6 en cada una.
dibujarRuleta
Genera árboles basados en sectores o resultados de una ruleta.		 
DiarbolAuto.dibujarRuleta('#vis', {
  giros: 1,
  sectores: [
    { label: '1', value: 1, peso: 1 },
    { label: '2', value: 2, peso: 1 },
    { label: '3', value: 3, peso: 1 }
  ]
});
Un árbol con una etapa y una rama por sector definido.
dibujarExtraccionConReposicion
Modela urnas donde cada elemento vuelve a la urna.		 
DiarbolAuto.dibujarExtraccionConReposicion('#vis', {
  elementos: [
    { label: 'Roja', nodeLabel: 'R', value: 1, count: 2, tipo: 'entero', dominio: 'urna' },
    { label: 'Azul', nodeLabel: 'A', value: 0, count: 1, tipo: 'entero', dominio: 'urna' }
  ],
  extracciones: 2
});
Árbol donde la probabilidad se mantiene en cada nivel porque los elementos regresan a la urna.
dibujarExtraccionSinReposicion
Simula urnas donde el espacio muestral se reduce.		 
DiarbolAuto.dibujarExtraccionSinReposicion('#vis', {
  elementos: [
    { label: 'Roja', nodeLabel: 'R', value: 1, count: 2, tipo: 'entero', dominio: 'urna' },
    { label: 'Azul', nodeLabel: 'A', value: 0, count: 1, tipo: 'entero', dominio: 'urna' }
  ],
  extracciones: 2
});
Árbol donde las probabilidades cambian en el segundo nivel según lo ya extraído.
dibujarBinario
Genera árboles con dos ramas por nivel, típicamente éxito/fracaso.		 
DiarbolAuto.dibujarBinario('#vis', {
  niveles: 3,
  ramaA: {
    label: 'Éxito',
    nodeLabel: 'E',
    value: 1,
    tipo: 'entero',
    dominio: 'binario'
  },
  ramaB: {
    label: 'Fracaso',
    nodeLabel: 'F',
    value: 0,
    tipo: 'entero',
    dominio: 'binario'
  }
});
Árbol binario de tres niveles con ramas explícitas A/B y semántica numérica estable.
dibujarExperimentoCompuesto
Genera árboles por etapas, cada una con sus propias ramas.		 
DiarbolAuto.dibujarExperimentoCompuesto('#vis', {
  stageLabels: ['Inicio', 'Moneda', 'Ruleta', 'Resultado final'],
  etapas: [
    {
      nombre: 'Moneda',
      ramas: [
        { label: 'Cara', nodeLabel: 'C', prob: '1/2', value: 1, tipo: 'entero', dominio: 'moneda' },
        { label: 'Sello', nodeLabel: 'S', prob: '1/2', value: 0, tipo: 'entero', dominio: 'moneda' }
      ]
    },
    {
      nombre: 'Ruleta',
      ramas: [
        { label: '1', nodeLabel: '1', prob: '1/3', value: 1, tipo: 'entero', dominio: 'ruleta' },
        { label: '2', nodeLabel: '2', prob: '1/3', value: 2, tipo: 'entero', dominio: 'ruleta' },
        { label: '3', nodeLabel: '3', prob: '1/3', value: 3, tipo: 'entero', dominio: 'ruleta' }
      ]
    }
  ]
});
Árbol por etapas donde cada camino representa un experimento compuesto completo.
dibujarCasos
Dibuja trayectorias específicas definidas por una lista de casos.		 
DiarbolAuto.dibujarCasos('#vis', {
  rootLabel: 'I',
  casos: [
    {
      lines: ['Pan A + Carne X'],
      camino: [
        { label: 'Pan A', nodeLabel: 'A', value: 'A', tipo: 'texto', dominio: 'pan' },
        { label: 'Carne X', nodeLabel: 'X', value: 'X', tipo: 'texto', dominio: 'carne' }
      ]
    }
  ]
});
Un árbol construido solo con los caminos definidos explícitamente en casos.

3. El Motor de Criterios (JSON DSL)

Esta es la herramienta para definir qué hojas del árbol deben resaltarse.

A. Operadores de Valor

{ "pos": 1 }              // Valor del 1er evento
{ "const": 7 }            // Valor constante
{ "sum": [{ "pos": 1 }, { "pos": 2 }] } // Suma de posiciones

B. Operadores de Comparación

{ "eq": [A, B] }   // A igual a B
{ "gt": [A, B] }   // A mayor que B
{ "lt": [A, B] }   // A menor que B
{ "gte": [A, B] }  // A mayor o igual que B
{ "lte": [A, B] }  // A menor o igual que B

C. Operadores Lógicos

{ "and": [ {regla1}, {regla2} ] } // Ambas deben cumplirse
{ "or":  [ {regla1}, {regla2} ] }      // Al menos una debe cumplirse
{ "not": {regla} }                     // Negación

4. Ejemplo de Implementación Completa

Resaltar “La primera es Cara (1) y la suma total es exactamente 2”:

// 1. Instanciar
var inst = DiarbolAuto.dibujarMoneda('#arbol', { lanzamientos: 3 });

// 2. Definir evento semántico
DiarbolEventos.definirEventoDesdeExpresion(inst, 'EventoA', {
  "and": [
    { "eq": [ { "pos": 1 }, { "const": 1 } ] },
    { "eq": [ { "sum": [ { "pos": 1 }, { "pos": 2 }, { "pos": 3 } ] }, { "const": 2 } ] }
  ]
});

// 3. Resaltar
DiarbolEventos.resaltarEvento(inst, 'EventoA', {
  color: '#27ae60'
});
Nota técnica: el sistema utiliza el módulo DiarbolCore para el manejo exacto de racionales, y la mezcla de configuración debe admitir también callbacks como crearLineasLeaf cuando un auto los necesite.