#!/usr/bin/perl
# din2mac: del sistema de ecuaciones de Calcula (.din, .mdin) al archivo de
# lote de Maxima (.mac), para resolverlo ANALITICAMENTE. Es el espejo de
# ds2cir: no corre nada, escribe el .mac; lo corre el lanzador (--motor
# maxima).
#
#     din2mac caso.din                      escribe caso.mac al lado
#     din2mac caso.din salida.mac           donde se diga
#     din2mac --dat caso.dat caso.din       de ahi saca T, TIEMPOFINAL y las
#                                           salidas con sus nombres del pedido
#     din2mac --desde 0 --hasta 10 --puntos 300 caso.din
#     din2mac --desde 0 --hasta 6 --paso 1/10 caso.din
#     din2mac -n caso.din                   dice que haria y no escribe
#
# y, para las llaves, tres cosas mas sobre el mismo .mdin de una
# configuracion (d2datdinc --llaves S1=0 --din deja NOMBRE-0I.mdin, el
# instante; NOMBRE-0E.mdin, el equilibrio; NOMBRE-0D.mdin, el continuo):
#
#     din2mac --horario caso.horario caso-0I.mdin
#         no resuelve el circuito: resuelve LAS CONDICIONES de las llaves y
#         escribe en que intervalos de tiempo vale cada configuracion
#     din2mac --t0 1 --fin 3 --estado il1=1/2,il2=1/2 \
#             --estados-fin caso-2.estados caso-1I.mdin caso-2.mac
#         un intervalo: la solucion cerrada desde t0 con esas condiciones
#         iniciales, la tabla entre t0 y fin, y los estados en fin
#     din2mac --equilibrio caso-3.estados --estado pre_il1=1,pre_il2=0 caso-0E.mdin
#         el trasvase instantaneo de carga o de flujo al conmutar
#
# Pedido del autor (04/11/2026): "que el mismo lanzador que envia a siru,
# spice y sceptre mande a maxima"; y "para el caso de llaves podes
# articularlo con calcula, que hace ese trabajo de dividir por casos". La
# entrada es el .din porque ahi el modelo YA ES un sistema de ecuaciones: el
# circuito lo paso d2datdinc, el mismo armador que prepara el sistema para
# siru y para Calcula. Asi el puente no vuelve a armar ecuaciones ni duplica
# el lector del .d o del .dsa.
#
# Lo que el .mac le pide a Maxima:
#
#   funciones    NOMBRE(args) = cuerpo        ->  siru_NOMBRE(args) := cuerpo
#   parametros   c1 = 1                       ->  siru_c1: 1
#   estados      qc1 = 1 (el valor del .din)  ->  atvalue(siru_qc1(t),t=0,1)
#                                                 LA CONDICION INICIAL
#   derivadas    dqc1dt (del  # @estado)      ->  diff(siru_qc1(t),t)
#   incognitas   ic1, u1, vc1 ...             ->  siru_ic1(t), ...
#   ecuaciones   dqc1dt - ic1 = 0             ->  una ecuacion de desolve
#
# y resuelve con desolve, que es la transformada de Laplace: el sistema
# entero, con sus ecuaciones algebraicas adentro (un DAE lineal de indice 1
# se resuelve igual; medido con abc-de-d2datdinc.din: qc1 = %e^-t, y con el
# resto de las variables del circuito despejadas).
#
# Todos los nombres del .din van con el prefijo siru_ porque Maxima tiene los
# suyos y chocan: 'ic1' es su funcion de condiciones iniciales y el sistema de
# abc no se podia ni plantear ("Too few arguments supplied to ic1"). El
# prefijo es uniforme, asi que sigue siendo un nombre por variable.
#
# EL TIEMPO. Maxima resuelve con desolve, que es Laplace: las condiciones
# iniciales van en t=0 y no en otra parte. Asi que el tiempo del .mac es el
# tiempo LOCAL del intervalo y el de la corrida es t + t0 (--t0): donde el
# .din dice T, el .mac dice (t + t0). Las tablas y los estados finales se
# escriben en tiempo de la corrida.
#
# LAS LLAVES. Cada configuracion es un sistema distinto --el mismo circuito
# con la llave cerrada o abierta, y con la ley del corte o del lazo que eso
# provoca-- y eso lo arma d2datdinc --llaves, que es el que divide por casos
# para Calcula. Aca se resuelve configuracion por configuracion:
#
#   1. --horario  resuelve las condiciones (T>1)*(T<3), T>=1, ... : las
#      evalua AL COMENZAR CADA PASO de la malla y abre un intervalo nuevo
#      donde la configuracion del paso difiere de la del paso anterior. El
#      instante de conmutacion es por lo tanto un punto de la malla, como en
#      siru --'se evalua al empezar cada paso; si cambia en medio de un paso,
#      la llave cambia en el siguiente' (slex/dsa/doc/GRAMATICA.tex)--
#      y no la raiz exacta de la condicion (decision del autor, 04/11/2026:
#      "las llaves al comenzar cada paso");
#   2. un intervalo por configuracion, con --t0, --fin y --estado: la formula
#      cerrada del intervalo y los estados al final, exactos;
#   3. --equilibrio entre un intervalo y el siguiente: el trasvase
#      instantaneo de carga o de flujo del .mdin de equilibrio, resuelto con
#      solve (es algebraico lineal), tambien exacto.
#
# Una condicion que depende del estado (IL1<0.3) no permite el horario de
# antemano: el llamador corre cada intervalo con --vigilar y la condicion se
# evalua SOBRE LA FORMULA CERRADA del intervalo, en cada punto de la malla;
# donde los bits difieren, el intervalo se corta ahi (DIN2MAC CONMUTA) y el
# modelo de la configuracion nueva se arma cuando aparece (08/11/2026).
# --horario queda para las condiciones que dependen solo del tiempo.
#
# El .mac escribe dos archivos al terminar:
#
#   BASE.analitica   la solucion en forma cerrada, una variable por renglon
#   BASE.tabla       esa solucion evaluada en la malla de la corrida
#
# y por la salida normal un renglon  DIN2MAC ESTADO: ...  que dice si quedo
# resuelta o por que no. No hay solucion cerrada mas que para lo que Maxima
# sabe resolver: desolve es para sistemas LINEALES. Lo que no entra se dice y
# no se escribe el .mac (estado 3):
#
#   - una tabla (tabla('1.txt',...)): no es una funcion analitica;
#   - un  # PENDIENTE  del .din: el sistema no esta completo;
#   - ninguna incognita, o las cuentas de ecuaciones e incognitas distintas;
#   - una condicion de llave que depende de una variable del circuito.
#
# Lo no lineal SI se escribe: lo rechaza Maxima, que es quien sabe, y el
# ESTADO lo dice (desolve deja un 'ilt(...) sin invertir cuando no puede).
#
# Copyright (C) Diego Saravia <dsa@unsa.edu.ar>
# GPL version 3 o posterior.
use strict;
use warnings;
use File::Basename qw(basename);
use Getopt::Long;
use JSON::PP qw(decode_json);

my ($ensayo, $ayuda, $dat, $desde, $hasta, $puntos) = (0, 0, '', undef, undef, undef);
my $paso_opt = '';
my $solo_analitica = 0;
my ($t0_opt, $fin_opt, $horario, $equilibrio, $estados_fin) = (undef, undef, '', '', '');
my $vigilar = '';
my @estado_opt;
GetOptions('n|ensayo' => \$ensayo, 'h|help' => \$ayuda, 'dat=s' => \$dat,
           'desde=f' => \$desde, 'hasta=f' => \$hasta, 'puntos=i' => \$puntos,
           'paso=s' => \$paso_opt, 'solo-analitica' => \$solo_analitica,
           't0=s' => \$t0_opt, 'fin=s' => \$fin_opt, 'estado=s' => \@estado_opt,
           'horario=s' => \$horario, 'equilibrio=s' => \$equilibrio,
           'estados-fin=s' => \$estados_fin, 'vigilar=s' => \$vigilar)
    or $ayuda = 1;
if ($ayuda or @ARGV < 1 or @ARGV > 2) {
    print <<'FIN';
Uso: din2mac [-n] [--dat caso.dat] [--desde T0] [--hasta TF] [--puntos N|--paso P]
             [--t0 EXPR] [--fin EXPR] [--estado N=V,...] [--estados-fin ARCH]
             [--horario ARCH] [--equilibrio ARCH]  caso.din [salida.mac]
  --solo-analitica  escribe formulas sin evaluarlas en una tabla
  --dat     el .dat del mismo caso: de ahi salen T, TIEMPOFINAL y los nombres
            del pedido para las columnas
  --desde   el tiempo inicial de la MALLA (si no, el del .dat o el del .din)
  --hasta   el tiempo final de la malla (si no, TIEMPOFINAL del .dat)
  --puntos  intervalos uniformes (300 por omision; 301 puntos)
  --paso    el paso de la malla (si no, SIRU_PASO del DU): expresion exacta
            (1/10) o un numero (0.1). Es tambien el paso con que se evaluan
            las condiciones de las llaves, asi que con el paso de siru la
            conmutacion cae donde cae en siru
  --t0      el tiempo de la corrida en que arranca ESTE intervalo; el tiempo
            del .mac es local (t) y el de la corrida es t + t0
  --fin     donde termina este intervalo (si no, el final de la malla)
  --estado  las condiciones iniciales de los estados, exactas, de a pares
            NOMBRE=VALOR (en el equilibrio, los pre_NOMBRE)
  --estados-fin  archivo donde Maxima deja los estados al final del intervalo
  --vigilar S1=0,...  la configuracion de ESTE intervalo: las condiciones de
                 las llaves se evaluan sobre la formula cerrada en cada punto
                 de la malla y, donde los bits difieren (o una parada da 0),
                 el intervalo se corta ahi: la tabla y los estados finales
                 llegan hasta el corte, y la salida dice
                 DIN2MAC CONMUTA: t | t_float | bits  (o DIN2MAC PARA:).
                 Tambien dice DIN2MAC BITS0: los bits al comenzar, para que
                 el llamador verifique que la configuracion es estable
  --horario      no resuelve el circuito: resuelve las condiciones de las
                 llaves --evaluadas al comenzar cada paso de la malla, como
                 siru-- y escribe en que intervalos vale cada configuracion
  --equilibrio   el .mdin es uno de equilibrio (el trasvase al conmutar):
                 se resuelve con solve y los estados van a ese archivo
  -n        dice que haria y no escribe
Escribe caso.mac: el sistema del .din para resolver con Maxima (desolve), con
las condiciones iniciales de los estados. Al correrlo, Maxima deja
caso.analitica (la forma cerrada) y caso.tabla (esa solucion en la malla).
FIN
    exit($ayuda ? 0 : 2);
}
my $entrada = $ARGV[0];
-f $entrada or die "din2mac: no existe $entrada\n";
my $salida = $ARGV[1] // do { (my $s = $entrada) =~ s/\.m?din\z/.mac/i; $s eq $entrada ? "$entrada.mac" : $s };
(my $base = $salida) =~ s/\.mac\z//i;
# El lector comun deja los controles de DU en GLOBAL.control.
# Una opcion explicita de malla prevalece sobre el paso declarado alli.
my $datos_malla = {};
if ($dat) {
    open my $d, '<', $dat or die "din2mac: $dat: $!\n";
    local $/; $datos_malla = decode_json(<$d>); close $d;
}
if (!defined $puntos && $paso_opt eq '') {
    my $v = $datos_malla->{GLOBAL}{control}{SIRU_PASO}{value};
    if (defined $v) {
        die "din2mac: SIRU_PASO requiere un unico valor\n"
            unless ref($v) eq 'ARRAY' && @$v == 1;
        $paso_opt = $v->[0];
    }
}
$paso_opt ne '' && defined $puntos
    and die "din2mac: --puntos y --paso son excluyentes\n";
$puntos //= 300;
$puntos > 0 or die "din2mac: --puntos tiene que ser positivo\n";
my $paso_num;
if ($paso_opt ne '') {
    $paso_opt =~ m{\A[-+0-9.eE*/() ]+\z}
        or die "din2mac: paso invalido: '$paso_opt'\n";
    $paso_num = eval $paso_opt;
    defined $paso_num && $paso_num > 0 && $paso_num < 1e308
        or die "din2mac: el paso debe ser positivo y finito\n";
}
# los pares de --estado: las comas de arriba separan, las de adentro de un
# parentesis no (un valor exacto de Maxima puede traer atan2(a,b))
sub pares_estado {
    my ($texto) = @_;
    my @partes;
    my ($actual, $prof) = ('', 0);
    for my $c (split //, $texto) {
        if    ($c eq '(' or $c eq '[') { $prof++ }
        elsif ($c eq ')' or $c eq ']') { $prof-- }
        if ($c eq ',' and $prof == 0) { push @partes, $actual; $actual = ''; next }
        $actual .= $c;
    }
    push @partes, $actual if $actual =~ /\S/;
    return @partes;
}
my %estado_dado;
for my $par (map { pares_estado($_) } @estado_opt) {
    $par =~ /\A\s*(\w+)\s*=\s*(.*\S)\s*\z/
        or die "din2mac: --estado se escribe NOMBRE=VALOR, no '$par'\n";
    $estado_dado{$1} = $2;
}
my $modo = $horario ? 'horario' : $equilibrio ? 'equilibrio' : 'intervalo';
my $estatico = $modo eq 'equilibrio' ? 1 : 0;
my $t0 = defined $t0_opt && $t0_opt =~ /\S/ ? $t0_opt : '0';

# ---- 1. leer el .din
# Las secciones van sin sangria (funciones, variables, ecuaciones, tablas) y
# sus renglones sangrados. Lo que Calcula no usa viaja comentado: el par
# estado/derivada en  # @estado, y al final los bloques  # parametros,
# # corrida,  # estados,  # salidas,  # llaves  y  # equilibrio  con sus
# renglones de tres espacios (slex/din/README.md 4).
my (%derivada, %valor, @ecuaciones, @funciones, @pendientes, @tablas);
my (%parametro, %estado_valor, @salidas, $tiempo, @llaves, %equil_de, %equil_fuente);
my ($seccion, $comentario) = ('', '');
open my $fh, '<', $entrada or die "din2mac: $entrada: $!\n";
while (my $l = <$fh>) {
    chomp $l;
    if ($l =~ /^#\s*\@estado\s+(\S+)\s+(\S+)/) { $derivada{$1} = $2; next }
    if ($l =~ /^#\s*PENDIENTE\b/)              { push @pendientes, $l; next }
    if ($l =~ /^#\s{3,}(\S+)\s+(.*\S)\s*\z/ and $comentario) {
        my ($k, $v) = ($1, $2);
        $parametro{$k}    = $v if $comentario eq 'parametros';
        $estado_valor{$k} = $v if $comentario eq 'estados';
        push @salidas, [$k, $v] if $comentario eq 'salidas';
        push @llaves,  [$k, $v] if $comentario eq 'llaves';
        # el equilibrio puede traer una tercera palabra, 'fuente': el estado
        # que impone una fuente (slex/din/README.md 6). El dato es el pre_
        if ($comentario eq 'equilibrio') {
            my ($pre, @mas) = split ' ', $v;
            $equil_de{$k} = $pre;
            $equil_fuente{$k} = 1 if grep { $_ eq 'fuente' } @mas;
        }
        $tiempo = $v if $comentario eq 'corrida' and $k eq 'tiempo';
        next;
    }
    if ($l =~ /^#\s*(parametros|corrida|estados|salidas|llaves|equilibrio)\s*\z/) { $comentario = $1; next }
    next if $l =~ /^\s*#/;
    if ($l =~ /^(funciones|variables|ecuaciones|tablas)\s*\z/) { $seccion = $1; $comentario = ''; next }
    next unless $l =~ /\S/;
    if ($seccion eq 'variables' and $l =~ /^\s+(\S+)\s*=\s*(.*?)\s*(?:\[.*)?\z/) {
        $valor{$1} = $2; next;
    }
    if ($seccion eq 'ecuaciones' and $l =~ /\S/) {
        (my $e = $l) =~ s/\s*#.*\z//;        # la marca  # @lineal
        push @ecuaciones, $e if $e =~ /\S/;
        next;
    }
    if ($seccion eq 'funciones' and $l =~ /^\s+(\w+)\s*\(([^)]*)\)\s*=\s*(.*\S)/) {
        push @funciones, [$1, $2, $3]; next;
    }
    push @tablas, $l if $seccion eq 'tablas';
}
close $fh;
$tiempo //= 't';

sub falla { my ($motivo) = @_; print "din2mac: $motivo\n"; exit 3 }

# ---- 2. las condiciones: las llaves y las paradas
# El .mdin del instante trae, ademas del circuito, la condicion de cada llave
# (llave_<rama> = 1 cerrada, 0 abierta) y las de parada (seguir_<n>). No son
# ecuaciones del circuito: son el horario, y salen del sistema.
my %rama_de = map { $_->[1] => $_->[0] } @llaves;
my (%condicion, @orden_cond, @eq);
for my $e (@ecuaciones) {
    if ($e =~ /\A\s*(\w+)\s*=\s*(.*\S)\s*\z/
        and ($rama_de{$1} or $1 =~ /\Aseguir_\w+\z/)) {
        $condicion{$1} = $2; push @orden_cond, $1; next;
    }
    push @eq, $e;
}
@ecuaciones = @eq;

# ---- 3. que es cada nombre
# Un parametro es un dato del sistema; un estado y lo demas son incognitas. La
# derivada de un estado no es una incognita mas: es diff(estado(t),t).
# El .mdin de una configuracion no lleva  # @estado : ahi el par estado y
# derivada sale del nombre, d<estado>dt, que es como los escribe d2datdinc.
unless (%derivada) {
    for my $e (sort keys %estado_valor) {
        my $d = "d${e}dt";
        $derivada{$e} = $d if exists $valor{$d};
    }
    if (keys(%derivada) != keys(%estado_valor) and $modo ne 'equilibrio') {
        my @sin = grep { !$derivada{$_} } sort keys %estado_valor;
        falla("no encuentro la derivada de " . join(', ', @sin)
              . " (ni  # \@estado  ni d<estado>dt): no se que ecuacion es diferencial");
    }
}
# en el equilibrio los pre_ESTADO son datos (vienen de --estado), no incognitas
if ($modo eq 'equilibrio') {
    %derivada = ();
    for my $e (sort keys %equil_de) {
        my $pre = $equil_de{$e};
        $parametro{$pre} = $estado_dado{$pre} // $valor{$pre} // 0;
    }
}
my %es_derivada = map { $_ => 1 } values %derivada;
my @estados = sort keys %derivada;
# exists y no el valor: un parametro en 0 --s1, la llave abierta-- es un dato
# igual (sin exists, s1 entraba como incognita y el sistema no cerraba)
my @incognitas = sort grep { !exists $parametro{$_} and !$es_derivada{$_}
                             and !exists $condicion{$_} and $_ ne $tiempo } keys %valor;
my %es_incognita = map { $_ => 1 } @incognitas;
my %es_funcion = map { $_->[0] => 1 } @funciones;
# las intrinsecas que comparten ExprTk y Maxima, con el mismo significado
my %INTRINSECA = map { $_ => 1 } qw(sin cos tan asin acos atan atan2 sinh cosh tanh
                                    exp log sqrt abs min max floor ceiling signum);

falla("el .din tiene " . scalar(@pendientes) . " PENDIENTE: el sistema no esta completo"
      . "\n  " . join("\n  ", @pendientes)) if @pendientes;
if ($modo eq 'horario') {
    falla("el .din no trae ninguna condicion de llave: no hay horario que resolver")
        unless @orden_cond;
} else {
    falla("el .din no declara ninguna incognita") unless @incognitas;
    falla("ecuaciones (" . scalar(@ecuaciones) . ") e incognitas (" . scalar(@incognitas)
          . ") no coinciden: el sistema no esta determinado") if @ecuaciones != @incognitas;
}

# ---- 4. una expresion del .din, en Maxima
# Se recorre por nombres: cada identificador es una cosa distinta y lo demas
# queda como esta. ** de ExprTk es ^ de Maxima. El tiempo de la corrida es el
# local mas t0 (con --t0; sin el, los dos son el mismo).
$t0 = $desde // $datos_malla->{GLOBAL}{defpar}{T}{value}
    // (exists $valor{$tiempo} ? $valor{$tiempo} : 0) unless defined $t0_opt;
my $tiempo_maxima = $t0 eq '0' ? 't' : "(t + ($t0))";
sub a_maxima {
    my ($expr, $solo_tiempo) = @_;
    $expr =~ s/\*\*/^/g;
    my $out = '';
    while (length $expr) {
        if ($expr =~ s/\A([A-Za-z_]\w*)\s*(\()?//) {
            my ($nombre, $abre) = ($1, $2 // '');
            my $bajo = lc $nombre;
            if ($nombre eq $tiempo and not $abre) { $out .= $tiempo_maxima }
            elsif ($abre and ($INTRINSECA{$bajo} or $INTRINSECA{$nombre})) { $out .= "$bajo(" }
            elsif ($abre and $bajo eq 'tabla') {
                falla("la ecuacion usa una tabla y una tabla no es una funcion analitica:\n  $_[0]");
            }
            elsif ($abre and $es_funcion{$nombre}) { $out .= "siru_$nombre(" }
            elsif ($abre) {
                falla("no se que es la funcion '$nombre' de la ecuacion:\n  $_[0]");
            }
            elsif (my $estado = $es_derivada{$nombre} ? (grep { $derivada{$_} eq $nombre } @estados)[0] : undef) {
                $out .= "diff(siru_$estado(t),t)";
            }
            elsif ($es_incognita{$nombre}) {
                falla("la condicion '$_[0]' depende de $nombre, una variable del circuito:"
                      . " todavia solo se resuelven las condiciones que dependen del tiempo")
                    if $solo_tiempo;
                $out .= $estatico ? "siru_$nombre" : "siru_$nombre(t)";
            }
            elsif (exists $parametro{$nombre} or exists $valor{$nombre}) { $out .= "siru_$nombre" }
            else { falla("no se que es '$nombre' en:\n  $_[0]") }
            next;
        }
        # un numero, con el exponente de Fortran (2D1) ya traducido por din
        if ($expr =~ s/\A(\d+\.?\d*(?:[eE][-+]?\d+)?|\.\d+(?:[eE][-+]?\d+)?)//) { $out .= $1; next }
        $expr =~ s/\A(\s+)// and do { $out .= ' '; next };
        $expr =~ s/\A(.)// and do { $out .= $1; next };
    }
    return $out;
}

# ---- 5. el tiempo de la corrida y las columnas
# El .din no lleva el tiempo final: es del uso, no del modelo (en el .dat esta
# en GLOBAL.defpar.TIEMPOFINAL; en el par M/DU, en DATOS del DU).
my ($malla0, $tf) = ($desde, $hasta);
my $defpar = $datos_malla->{GLOBAL}{defpar} // {};
$tf //= $defpar->{TIEMPOFINAL}{value};
$malla0 //= $defpar->{T}{value};
$malla0 //= exists $valor{$tiempo} ? $valor{$tiempo} + 0 : 0;
if (defined $tf) {
    die "din2mac: tiempo final anterior al inicial\n" if $tf < $malla0;
}
if (not defined $tf and $modo ne 'equilibrio') {
    print "din2mac: no se el tiempo final (ni --hasta ni TIEMPOFINAL en el .dat):"
        . " la tabla queda sin escribir, la solucion analitica no\n";
}
my $fin = defined $fin_opt && $fin_opt =~ /\S/ ? $fin_opt : (defined $tf ? $tf : undef);
# Con --paso el paso es el dado y los puntos son cuantos entran en la corrida
# (el ultimo puede pasarse del final: los que caen afuera del intervalo no se
# escriben, y el final siempre lleva su renglon). Sin --paso, al reves: el
# paso es (hasta - desde) / puntos.
if (defined $paso_num and defined $tf) {
    my $cuantos = ($tf - $malla0) / $paso_num;
    $puntos = int($cuantos) + (abs($cuantos - int($cuantos)) > 1e-9 ? 1 : 0);
    $puntos >= 1 or $puntos = 1;
}
my $paso_mac = $paso_opt =~ /\S/ ? "($paso_opt)"
             : "ratsimp(((" . (defined $tf ? $tf : 0) . ") - ($malla0)) / $puntos)";
# Las columnas: las salidas del pedido, con su nombre (VCA) y su variable
# (vca). Sin bloque de salidas, todas las incognitas.
my @columnas = @salidas ? @salidas : map { [uc $_, $_] } @incognitas;
my @fuera = grep { my $v = $_->[1]; !$es_incognita{$v} and !exists $valor{$v} and $v ne $tiempo } @columnas;
if (@fuera) {
    print "din2mac: salidas que el sistema no define, quedan afuera: "
        . join(', ', map { $_->[0] } @fuera) . "\n";
    my %fuera = map { $_->[1] => 1 } @fuera;
    @columnas = grep { !$fuera{$_->[1]} } @columnas;
}
@columnas = grep { $_->[1] ne $tiempo } @columnas;   # el tiempo va siempre primero

if ($ensayo) {
    print "din2mac: $entrada -> $salida ($modo)\n";
    print "  estados:    ", join(', ', map { "$_=" . ($estado_dado{$_} // $estado_valor{$_} // $valor{$_} // '?') } @estados), "\n";
    print "  incognitas: ", join(', ', @incognitas), "\n";
    print "  parametros: ", join(', ', map { "$_=$parametro{$_}" } sort keys %parametro), "\n";
    print "  ecuaciones: ", scalar(@ecuaciones), "\n";
    print "  condiciones: ", join(', ', map { "$_ = $condicion{$_}" } @orden_cond), "\n" if @orden_cond;
    print "  columnas:   ", join(', ', map { $_->[0] } @columnas), "\n";
    printf "  malla:      %s a %s en %d puntos (paso %s); intervalo %s a %s\n",
           $malla0, (defined $tf ? $tf : '?'), $puntos,
           ($paso_opt =~ /\S/ ? $paso_opt : '(hasta-desde)/puntos'),
           $t0, (defined $fin ? $fin : '?');
    exit 0;
}

# ---- 5 bis. la vigilancia de las llaves de ESTE intervalo (--vigilar).
# Las condiciones que dependen del estado no permiten calcular el horario de
# antemano: el modelo de cada configuracion se arma cuando la configuracion
# APARECE (pedido del autor, 08/11/2026). El intervalo corre con sus bits y,
# sobre la formula cerrada, se evalua cada condicion en cada punto de la
# malla: donde los bits difieren, el intervalo se corta y el llamador arma la
# configuracion nueva.
my (@vig_llaves, @vig_seguir, $vig_actual);
if ($vigilar ne '') {
    falla("--vigilar es del modo intervalo") if $modo ne 'intervalo';
    @vig_llaves = grep { $rama_de{$_} } @orden_cond;
    @vig_seguir = grep { /\Aseguir_/ } @orden_cond;
    falla("--vigilar: el .din no trae condiciones de llave") unless @vig_llaves;
    my %vig = map { my ($r,$b) = split /=/, $_, 2;
                    falla("--vigilar se escribe RAMA=0|1, no '$_'")
                        unless defined $b && $b =~ /\A[01]\z/;
                    (uc $r, $b) } split /,/, $vigilar;
    $vig_actual = join ',', map { my $r = uc $rama_de{$_};
        falla("--vigilar no dice la llave $rama_de{$_}") unless exists $vig{$r};
        "$r=$vig{$r}" } @vig_llaves;
}

# ---- 6. el .mac
my @e_maxima = map { my $e = $_; my $m = a_maxima($e);
                     $m =~ /=/ ? $m : "$m = 0" } @ecuaciones;
my @vars_maxima;
{
    my $f = sub { my ($n) = @_; $estatico ? "siru_$n" : "siru_$n(t)" };
    my %vista;
    @vars_maxima = grep { !$vista{$_}++ } (map { $f->($_) } @estados),
                                          (map { $f->($_) } grep { !$derivada{$_} } @incognitas);
}

open my $out, '>', $salida or die "din2mac: no pude escribir $salida: $!\n";
my $nombre_din = basename($entrada);
print {$out} <<"FIN";
/* $base.mac: escrito por din2mac desde $nombre_din. No editar: se rehace.
   El sistema del .din resuelto en forma cerrada con Maxima. Los nombres
   llevan el prefijo siru_ porque los de Maxima chocan con los del circuito
   (ic1, bc2, ...). Dice por la salida normal como termino, en el renglon
   DIN2MAC ESTADO. */
ratprint: false\$
FIN
if (@funciones) {
    print {$out} "\n/* las funciones del modelo */\n";
    for my $f (@funciones) {
        my ($n, $args, $cuerpo) = @$f;
        my @a = map { my $x = $_; $x =~ s/\s//g; "siru_arg_$x" } split /,/, $args;
        my $c = $cuerpo;
        # los argumentos formales no son variables del sistema
        for my $i (0 .. $#a) {
            my $formal = (split /,/, $args)[$i]; $formal =~ s/\s//g;
            $c =~ s/\b\Q$formal\E\b/$a[$i]/g;
        }
        $c =~ s/\*\*/^/g;
        $c =~ s/\b(SIN|COS|TAN|EXP|LOG|SQRT|ABS|ATAN)\b/lc $1/ge;
        print {$out} "siru_$n(" . join(', ', @a) . ") := $c\$\n";
    }
}
print {$out} "\n/* los parametros: datos del sistema */\n";
print {$out} "siru_$_: $parametro{$_}\$\n" for sort keys %parametro;

# ---- 6 bis. el horario de las llaves
# No se resuelve el circuito: se resuelven LAS CONDICIONES, y se las evalua
# AL COMENZAR CADA PASO de la malla, como siru (decision del autor,
# 04/11/2026: "las llaves al comenzar cada paso"). La configuracion que sale
# de evaluar en t_k vale para todo el paso [t_k, t_k+1), asi que el instante
# de conmutacion es un punto de la malla y no la raiz exacta de la condicion:
# con  (T>1)  el paso que empieza en T=1 todavia tiene la llave abierta --la
# condicion es falsa justo ahi-- y cierra en el punto siguiente, que es lo
# que hace siru: 'se evalua al empezar cada paso; si cambia en medio de un
# paso, la llave cambia en el siguiente' (slex/dsa/doc/GRAMATICA.tex).
if ($modo eq 'horario') {
    my @c;
    for my $v (@orden_cond) {
        my $rama = $rama_de{$v} // $v;
        push @c, '[ "' . $rama . '", "' . $v . '", ' . a_maxima($condicion{$v}, 1) . ' ]';
    }
    my $tfin = defined $tf ? $tf : $fin;
    defined $tfin or falla("sin tiempo final no hay horario: use --hasta o --dat");
    print {$out} <<"FIN";

/* las condiciones: [rama, variable, condicion]. Las de parada (seguir_N)
   terminan la corrida; las de llave eligen la configuracion. */
din2mac_conds: [
  @{[ join(",\n  ", @c) ]}
]\$
din2mac_t0: $malla0\$
din2mac_tf: $tfin\$
din2mac_puntos: $puntos\$
/* el paso de la malla, el mismo de la tabla: el de --paso tal cual, o
   (hasta - desde) / puntos. Sale exacto si lo que se le dio es exacto, y
   entonces tambien son exactos los instantes de conmutacion y los estados
   que se pasan de un intervalo al siguiente. */
din2mac_paso: $paso_mac\$
FIN
    print {$out} <<'FIN';

/* la condicion como numero (0 o 1): las comparaciones pasan a charfun */
din2mac_chf(e) := if mapatom(e) then e
  elseif member(op(e), ["<", ">", "<=", ">=", "=", "#"]) then charfun(e)
  else apply(op(e), map(din2mac_chf, args(e)))$
din2mac_valor(c, tt) := block([v],
  v: ev(din2mac_chf(c), t = tt),
  if numberp(v) then v else ev(din2mac_chf(c), t = float(tt)))$

/* la configuracion del paso que empieza en tt, y si la corrida sigue */
din2mac_bits(tt) := block([b: ""],
  for c in din2mac_conds do
    if not ssearch("seguir_", second(c)) # false then
      b: sconcat(b, if b = "" then "" else ",", first(c), "=",
                 string(din2mac_valor(third(c), tt))),
  b)$
din2mac_sigue(tt) := block([v: true],
  for c in din2mac_conds do
    if ssearch("seguir_", second(c)) # false
       and din2mac_valor(third(c), tt) = 0 then v: false,
  v)$

/* el recorrido de la malla: se evalua al comenzar cada paso --de ahi que el
   ultimo punto que se mira es el comienzo del ultimo paso-- y se abre un
   intervalo nuevo donde la configuracion difiere de la del paso anterior.
   Los pasos seguidos con la misma configuracion quedan en un intervalo
   solo, y una condicion de parada en 0 termina la corrida en ese punto. */
din2mac_lineas: []$
din2mac_i: 0$
block([k, tt, bits, ant: false, desde: false],
  for k: 0 thru din2mac_puntos - 1 do (
    tt: din2mac_t0 + din2mac_paso * k,
    if float(tt) >= float(din2mac_tf) then k: din2mac_puntos + 1
    elseif not din2mac_sigue(tt) then (
      if ant # false then (
        din2mac_lineas: append(din2mac_lineas, [[desde, tt, ant]]), ant: false),
      k: din2mac_puntos + 1)
    else (
      bits: din2mac_bits(tt),
      if ant = false then (desde: tt, ant: bits)
      elseif bits # ant then (
        din2mac_lineas: append(din2mac_lineas, [[desde, tt, ant]]),
        desde: tt, ant: bits))),
  if ant # false then
    din2mac_lineas: append(din2mac_lineas, [[desde, din2mac_tf, ant]]))$
FIN
    print {$out} <<"FIN";
with_stdout("$horario",
  printf(true, "# horario de las llaves, escrito por maxima (din2mac desde $nombre_din)~%"),
  printf(true, "# la condicion se evalua al comenzar cada paso de la malla~%"),
  printf(true, "# intervalo NRO | desde | hasta | desde (numero) | hasta (numero) | llaves~%"),
  for din2mac_l in din2mac_lineas do (
    printf(true, "intervalo ~d | ~a | ~a | ~a | ~a | ~a~%", din2mac_i,
           string(first(din2mac_l)), string(second(din2mac_l)),
           float(first(din2mac_l)), float(second(din2mac_l)), third(din2mac_l)),
    din2mac_i: din2mac_i + 1))\$
printf(true, "DIN2MAC ESTADO: ~a~%",
       if din2mac_lineas = [] then "sin solucion analitica; el horario quedo vacio"
       else sconcat("resuelto, ", length(din2mac_lineas), " intervalos"))\$
FIN
    close $out or die "din2mac: no pude cerrar $salida: $!\n";
    print "din2mac: $salida (horario de ", scalar(@orden_cond), " condiciones)\n";
    exit 0;
}

# ---- 6 ter. el equilibrio: el trasvase instantaneo al conmutar
# Al cerrarse un lazo de capacitores o abrirse un corte de bobinas, la carga
# o el flujo se redistribuyen de golpe: el .mdin de equilibrio tiene los
# pre_ESTADO como datos y los ESTADO como incognitas. Es algebraico y lineal:
# solve lo resuelve exacto.
if ($modo eq 'equilibrio') {
    my @e_estados = sort keys %equil_de;
    print {$out} "\n/* el sistema del equilibrio */\n";
    print {$out} "din2mac_eqs: [\n  " . join(",\n  ", @e_maxima) . "\n]\$\n";
    print {$out} "din2mac_vars: [" . join(', ', @vars_maxima) . "]\$\n";
    print {$out} <<'FIN';
din2mac_r: errcatch(solve(din2mac_eqs, din2mac_vars))$
din2mac_sol: if din2mac_r = [] or first(din2mac_r) = [] then false
             else first(first(din2mac_r))$
FIN
    my @lineas = map { "    printf(true, \"estado $_ | ~a~%\", string(subst(din2mac_sol, siru_$_)))" } @e_estados;
    print {$out} <<"FIN";
if din2mac_sol = false then
  printf(true, "DIN2MAC ESTADO: sin solucion analitica; el equilibrio no se pudo resolver~%")
else (
  printf(true, "DIN2MAC ESTADO: resuelto~%"),
  with_stdout("$equilibrio",
    printf(true, "# el equilibrio de $nombre_din: los estados despues del trasvase~%"),
@{[ join(",\n", @lineas) ]}))\$
FIN
    close $out or die "din2mac: no pude cerrar $salida: $!\n";
    print "din2mac: $salida (equilibrio de ", scalar(@e_estados), " estados)\n";
    exit 0;
}

# ---- 7. un intervalo: la solucion cerrada
print {$out} "\n/* las condiciones iniciales de los estados"
           . (%estado_dado ? " (del intervalo anterior)" : " (del .din)") . " */\n";
for my $e (@estados) {
    my $v = $estado_dado{$e} // $estado_valor{$e} // $valor{$e} // 0;
    print {$out} "atvalue(siru_$e(t), t = 0, $v)\$\n";
}
print {$out} "\n/* el sistema */\n";
print {$out} "din2mac_eqs: [\n  " . join(",\n  ", @e_maxima) . "\n]\$\n";
print {$out} "din2mac_vars: [" . join(', ', @vars_maxima) . "]\$\n";
print {$out} <<'FIN';

/* desolve es para sistemas lineales: si no puede, deja false, o un 'ilt(...)
   sin invertir, o constantes del arranque sin determinar. Las tres son "no
   hay forma cerrada" y se informan como tales. */
din2mac_r: errcatch(desolve(din2mac_eqs, din2mac_vars))$
din2mac_sol: if din2mac_r = [] then false else first(din2mac_r)$
/* con una sola ecuacion desolve devuelve la ecuacion, no una lista de una */
if din2mac_sol # false and not listp(din2mac_sol) then din2mac_sol: [din2mac_sol]$
din2mac_texto: if din2mac_sol = false then "" else string(din2mac_sol)$
din2mac_motivo:
  if din2mac_sol = false then "desolve no pudo con el sistema"
  elseif ssearch("ilt(", din2mac_texto) # false then "la transformada no se pudo invertir: el sistema no es lineal"
  elseif ssearch("laplace(", din2mac_texto) # false then "quedo una transformada sin resolver: el sistema no es lineal"
  else false$
FIN
my $lista_estados = join(', ', map { "\"siru_$_(0)\"" } @estados);
print {$out} <<"FIN";
/* una constante del arranque sin determinar queda como siru_x(0) */
din2mac_libres: if din2mac_motivo # false then []
  else sublist([$lista_estados], lambda([n], ssearch(n, din2mac_texto) # false))\$
if din2mac_motivo = false and din2mac_libres # [] then
  din2mac_motivo: sconcat("quedaron constantes sin determinar: ",
                          simplode(din2mac_libres, " "))\$
FIN
my $rango = $t0 eq '0' && !defined $fin_opt ? ''
          : " (intervalo de $t0 a " . (defined $fin ? $fin : '?') . ")";
my $metadatos_analitica = defined $fin ? "# SIMPLOT_INTERVALO $t0 $fin" : '# SIMPLOT_INTERVALO desconocido';
my $columnas_analitica = join(' ', map { $_->[0] . '=' . $_->[1] } @columnas);
print {$out} <<"FIN";

if din2mac_motivo # false then (
  printf(true, "DIN2MAC ESTADO: sin solucion analitica; ~a~%", din2mac_motivo),
  with_stdout("$base.analitica",
    printf(true, "# $nombre_din: sin solucion analitica (Maxima/desolve)~%"),
    printf(true, "# ~a~%", din2mac_motivo))
) else (
  printf(true, "DIN2MAC ESTADO: resuelto~%"),
  with_stdout("$base.analitica",
    printf(true, "# $nombre_din: la solucion analitica, escrita por maxima (din2mac)$rango~%"),
    printf(true, "# una variable por renglon, con el prefijo siru_ de los nombres del .din;~%"),
    printf(true, "# el tiempo t es el del intervalo: el de la corrida es t + ($t0)~%"),
    printf(true, "$metadatos_analitica~%"),
    printf(true, "# SIMPLOT_COLUMNAS $columnas_analitica~%"),
    for din2mac_e in din2mac_sol do printf(true, "~a~%", string(din2mac_e)))
)\$
FIN
# ---- 7 bis. la vigilancia: el corte del intervalo sobre la formula cerrada
my $fin_vig = defined $fin ? $fin : (defined $tf ? $tf : '0');
print {$out} "\ndin2mac_fin_ef: ($fin_vig)\$\n";
if ($vigilar ne '') {
    my @c = map { '[ "' . uc($rama_de{$_}) . '", ' . a_maxima($condicion{$_}) . ' ]' } @vig_llaves;
    my @sg = map { a_maxima($condicion{$_}) } @vig_seguir;
    print {$out} <<"FIN";

/* la vigilancia (--vigilar): los bits de este intervalo son
   $vig_actual y las condiciones se evaluan sobre la formula cerrada en
   cada punto de la malla; donde difieren, el intervalo se corta. */
din2mac_vconds: [
  @{[ join(",\n  ", @c) ]}
]\$
din2mac_vseguir: [@{[ join(', ', @sg) ]}]\$
din2mac_actual: "$vig_actual"\$
din2mac_vig_paso: $paso_mac\$
FIN
    print {$out} <<'FIN';
din2mac_vchf(e) := if mapatom(e) then e
  elseif member(op(e), ["<", ">", "<=", ">=", "=", "#"]) then charfun(e)
  else apply(op(e), map(din2mac_vchf, args(e)))$
/* la condicion, evaluada con la solucion en el tiempo local tl: 1 o 0 */
din2mac_vval(c, tl) := block([v],
  v: ev(din2mac_vchf(subst(din2mac_sol, c)), t = tl),
  if not numberp(v) then v: ev(din2mac_vchf(subst(din2mac_sol, c)), t = float(tl)),
  if numberp(v) and float(v) > 0.5 then 1 else 0)$
din2mac_vbits(tl) := simplode(
  makelist(sconcat(first(din2mac_vconds[i]), "=",
                   din2mac_vval(second(din2mac_vconds[i]), tl)),
           i, 1, length(din2mac_vconds)), ",")$
din2mac_vsigue(tl) := block([v: true],
  for c in din2mac_vseguir do if din2mac_vval(c, tl) = 0 then v: false, v)$
din2mac_corte: false$
din2mac_corte_tipo: false$
din2mac_corte_bits: false$
FIN
    print {$out} <<"FIN";
if din2mac_motivo = false then (
  printf(true, "DIN2MAC BITS0: ~a~%", din2mac_vbits(0)),
  block([k, tg, tl, tol: abs(float(din2mac_vig_paso)) * 1e-9],
    for k: 0 thru $puntos do (
      tg: ($malla0) + din2mac_vig_paso * k,
      if float(tg) > float($t0) + tol and float(tg) < float(din2mac_fin_ef) - tol then (
        tl: tg - ($t0),
        if not din2mac_vsigue(tl) then (
          din2mac_corte: tg, din2mac_corte_tipo: "PARA", k: $puntos + 1)
        elseif din2mac_vbits(tl) # din2mac_actual then (
          din2mac_corte: tg, din2mac_corte_tipo: "CONMUTA",
          din2mac_corte_bits: din2mac_vbits(tl), k: $puntos + 1)))),
  if din2mac_corte # false then (
    din2mac_fin_ef: din2mac_corte,
    printf(true, "DIN2MAC ~a: ~a | ~a | ~a~%", din2mac_corte_tipo,
           string(din2mac_corte), float(din2mac_corte),
           if din2mac_corte_tipo = "CONMUTA" then din2mac_corte_bits
           else din2mac_actual)))\$
FIN
}
if (defined $tf && !$solo_analitica) {
    my @expr = map { "subst(din2mac_sol, siru_" . $_->[1] . "(t))" } @columnas;
    my $cab = join(' ', 'TIME', map { $_->[0] } @columnas);
    my $fin_m = defined $fin ? $fin : $tf;
    # La malla es la de la corrida ($malla0 a $tf en $puntos puntos) y de ella
    # se escriben los puntos de ESTE intervalo, mas sus dos extremos: asi en
    # el instante de la conmutacion hay un renglon de cada configuracion,
    # como en el .simul de siru.
    print {$out} <<"FIN";

/* la solucion en la malla de la corrida: $malla0 a $tf en $puntos puntos, de
   $t0 a $fin_m. Es la formula evaluada, no una integracion: no tiene paso ni
   error de truncamiento. El tiempo de la tabla es el de la corrida. */
if din2mac_motivo = false then
block([din2mac_col, din2mac_tg, din2mac_paso, din2mac_a, din2mac_b, din2mac_tol, din2mac_fila],
  din2mac_col: [@{[ join(",\n                ", @expr) ]}],
  din2mac_a: $t0, din2mac_b: din2mac_fin_ef,
  din2mac_paso: $paso_mac,
  din2mac_tol: abs(din2mac_paso) * 1e-9,
  din2mac_fila(tg) := printf(true, "~{~a ~}~%",
    cons(float(tg), map(lambda([x], float(subst(t = tg - (din2mac_a), x))), din2mac_col))),
  with_stdout("$base.tabla",
    printf(true, "# $cab~%"),
    din2mac_fila(din2mac_a),
    for din2mac_k: 0 thru $puntos do (
      din2mac_tg: $malla0 + din2mac_paso * din2mac_k,
      if float(din2mac_tg) > float(din2mac_a) + din2mac_tol
         and float(din2mac_tg) < float(din2mac_b) - din2mac_tol
      then din2mac_fila(din2mac_tg)),
    if float(din2mac_b) > float(din2mac_a) + din2mac_tol then din2mac_fila(din2mac_b)))\$
FIN
}
if ($estados_fin and @estados) {
    my @lineas = map { "    printf(true, \"estado $_ | ~a~%\", string(ratsimp(subst(t = din2mac_tl, subst(din2mac_sol, siru_$_(t))))))" } @estados;
    my $fin_m = defined $fin ? $fin : (defined $tf ? $tf : '0');
    print {$out} <<"FIN";

/* los estados al final del intervalo, exactos: son las condiciones iniciales
   del intervalo que sigue (antes del trasvase, si hay que equilibrar). */
if din2mac_motivo = false then block([din2mac_tl: din2mac_fin_ef - ($t0)],
  with_stdout("$estados_fin",
    printf(true, "# los estados de $nombre_din al final efectivo del intervalo (din2mac/maxima)~%"),
    printf(true, "tiempo | ~a~%", string(din2mac_fin_ef)),
@{[ join(",\n", @lineas) ]}))\$
FIN
}
close $out or die "din2mac: no pude cerrar $salida: $!\n";
print "din2mac: $salida (", scalar(@ecuaciones), " ecuaciones, ",
      scalar(@incognitas), " incognitas, ", scalar(@estados), " estados)\n";
exit 0;
