Referencia de la Estructura sbcl_principal

Clase en la que se encuentran los diferentes slots utilizados para hacer funcionar la parte gráfica del programa. Más...

#include <sbcl_principal.h>

Diagrama de colaboración para sbcl_principal:

Collaboration graph
[leyenda]

Lista de todos los miembros.

Slots públicos

virtual void slt_abrirspc ()
 Este slot se encarga de abrir el fichero generado por el Xcircuit.
virtual void slt_abrirps ()
 Slot encargado de abrir la imagen del circuito para visualizar el mismo en pestaña Circuito.
virtual void slt_xcircuit ()
 Slot encargado de abrir el Xcircuit para realizar el diseño del circuito a través de la librería de elementos elaborada para Ávalon.
virtual void slt_resolver ()
 El slot resolver se encarga comenzar los procesos necesarios para la resolución del sistema.
virtual void slt_analisis ()
 Slot que se encarga de verificar que está seleccionado en tipo de análisis para así indicar a Ávalon como ha de comportarse en el análisis. Básicamente lo que hace es modificar los valores de unas variables en la clase basicos DATOS cuando el usuario cliquea en trasitorio o estacionario.
virtual void slt_seleccionfilasMDG ()
 Este Slot se encarga de detectar en que fila de la Qtable Matriz de Datos Generales se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla.
virtual void slt_seleccionfilasMN ()
 Este Slot se encarga de detectar en que fila de la Qtable Matriz de Nodos se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla.
virtual void slt_seleccionfilasMVC ()
 Este Slot se encarga de detectar en que fila de la Qtable Matriz de Valores Característicos se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla.
virtual void slt_solEstacionario (basicos *p_DATOS)
 Este Slot se encarga de escribir en pantalla la solución del sistema estacionario.
virtual void slt_calculadora ()
 Este Slot se encarga de lanzar una calculadora para posibles cálculos que el usuario pueda necesitar.
virtual void slt_prepara ()
 Este slot se encarga preparar la tabla de condiciones iniciales Entre las tareas que realiza este slot se encuentra:
.
virtual void slt_nuevoanalisis ()
 Este slot se encarga purgar los valores necesarios para comenzar con un análisis de un nuevo circuito.
virtual void slt_gnuplot ()
 Slot encargado de abrir el GNUPlot para realizar nuevos ploteos tras adaptar el script realizado por defecto.
virtual void slt_sobreQt ()
 Slot encargado de lanzar el diálogo de información de la versión de Qt utilizada.
virtual void slt_ayuda ()
 Slot encargado de abrir diálogo de información sobre el programa.
virtual void slt_sistemaestacionario ()
 Slot que carga el sistema a resolver del estacionario en pantalla.
virtual void slt_sistematransitorio ()
 Slot que carga los sistemas a resolver del transitorio en pantalla.
virtual void slt_solucionestacionario ()
 Slot que carga la solución del estacionario en pantalla.
virtual void slt_soluciontransitorio ()
 Slot que carga la solución del transitorio en pantalla.
virtual void slt_cargagrafico ()
 Este slot abre el gráfico realizado con el script por defecto en pantalla.
virtual void slt_abrescript ()
 Este slot abre el script que usa GNUPlot para generar el gráfico final de las variables calculadas.
virtual void slt_vermatrizT ()
 Este slot abre una visualización gráfica de la matriz sparse.
virtual void INFOgeneral (basicos *DATOS)
 Slot escargado de visualizar datos generales del circuito que se está analizando.

Métodos públicos

 sbcl_principal (QWidget *parent=0, const char *name=0, bool modal=FALSE, WFlags fl=0)
 Constructor de la clase principal.
 ~sbcl_principal ()
 Destructor de la clase principal.

Atributos públicos

basicos DATOS

Slots protegidos

virtual void slt_resolucion (basicos *p_DATOS)
 Este Slot se encarga de seguir el proceso de resolución de los sistemas de ecuaciones del circuito a analizar.

Descripción detallada

Clase en la que se encuentran los diferentes slots utilizados para hacer funcionar la parte gráfica del programa.

En esta clase se encuentran las principales líneas que hacen funcionar al programa.
Esta clase contiene los slots encargados de hacer que funciones los botones de la interfaz de usuario enlazando cuando es necesario con el resto de funciones existentes para que se ejecuten las operaciones que hacen posibles la obtención de las variables de los circuitos que se analizan.

Definición en la línea 20 del archivo sbcl_principal.h.

Documentación del constructor y destructor

sbcl_principal::sbcl_principal ( QWidget *  parent = 0,
const char *  name = 0,
bool  modal = FALSE,
WFlags  fl = 0 
)

Constructor de la clase principal.

Parámetros:
parent Nos indica de que QWidget depende

Definición en la línea 16 del archivo sbcl_principal.cpp.

00017            : dlg_principal ( parent,name, modal,fl )//Constructor de la sbcl
00018 {       
00019 }

sbcl_principal::~sbcl_principal (  ) 

Destructor de la clase principal.

Definición en la línea 21 del archivo sbcl_principal.cpp.

00022 {
00023 }

Documentación de las funciones miembro

void sbcl_principal::slt_abrirspc (  )  [virtual, slot]

Este slot se encarga de abrir el fichero generado por el Xcircuit.

Entre las tareas que realiza esta función se encuentra:

  • Abrir el fichero *spc generado con Xcircuit
  • Llamar a lee_elemento para asi clocar de forma correcta los valores en las tres Qtable existentes
  • Generar el archivo *.png de dicho fichero para poder mostrar en pantalla el gráfico del circuito
    Ver también:
    lee_elemento

Definición en la línea 26 del archivo sbcl_principal.cpp.

00027 {
00028         //Ventana diaologo para abrir el *.spc
00029         QString fichero_spc = QFileDialog::getOpenFileName("",
00030                     "Circuito (*.spc)",
00031                     this,
00032                     "open file dialog",
00033                     "Elige el Circuito a resolver" );   
00034         //Preparando direcciones de ficheros            
00035         DATOS.file_spc=fichero_spc; 
00036         QString fichero_ps = fichero_spc; fichero_ps.replace( ".spc", ".ps" );
00037         QString fichero_png = fichero_spc; fichero_png.replace(".spc",".png"); 
00038         DATOS.file_png=fichero_png;
00039         QString datos_xperm = fichero_spc; datos_xperm.replace(".spc","_x_perm.data"); 
00040         DATOS.datos_perm=datos_xperm;
00041         QString datos_xtrans = fichero_spc; datos_xtrans.replace(".spc","_x_trans.data"); 
00042         DATOS.datos_trans=datos_xtrans;
00043         QString datos_script = fichero_spc; datos_script.replace(".spc","_script.plot"); 
00044         DATOS.datos_script=datos_script;
00045         QString grafica = fichero_spc; grafica.replace(".spc","_grafica.png"); 
00046         DATOS.solucion=grafica;
00047         QString sol_trans = fichero_spc; sol_trans.replace(".spc","_sol_trans.data"); 
00048         DATOS.sol_trans=sol_trans;
00049         QString sol_perm = fichero_spc; sol_perm.replace(".spc","_sol_perm.data"); 
00050         DATOS.sol_perm=sol_perm;
00051 
00052         //transformando archivo gráfico a formato compatible con Qt
00053         QString comando = fichero_png;
00054         comando.prepend(" ");
00055         comando.prepend(fichero_ps);
00056         comando.prepend("convert ");//añade "convert " al string comando
00057         // ejecuta un comando de imagemagick para la conversion de imagen de ps a png
00058         system(comando);
00059 
00060         //Vista del Fichero por ventana
00061         QFile *Document = new QFile(fichero_spc);
00062         if (!Document->open(IO_ReadOnly)) 
00063         { 
00064         cout << tr("File not found.") << endl;
00065         return; 
00066         }
00067         //Determinando el número de elementos y escribiendo la matriz en la table de la GUI
00068         QStringList lines;
00069         QFile file( fichero_spc );
00070         int num_line_total = 1;//es el numero de lineas del fichero
00071         QTextStream stream( &file );
00072         QString line;
00073         int i=0, j=0;   
00074 
00075         /*Esta lectura crea las filas necesarias para 
00076         mostrar en la table los valores contenidos en el fichero *spc*/
00077          if ( file.open( IO_ReadOnly ) ) 
00078         {
00079         while ( !stream.atEnd() ) //lectura del fichero +.spc
00080                 {
00081                 line = stream.readLine(); // linea de texto excluyendo el '\n'
00082                 num_line_total++;
00083                 }
00084         lines += line;                  
00085         num_line_total=num_line_total-5;                
00086         tableMDG->insertRows(0,num_line_total); //creación de las filas necesarias
00087         tableMN->insertRows(0,num_line_total);          
00088         tableMVC->insertRows(0,num_line_total);                         
00089         //numero de elementos, se le resta 2 por la cabecera y tres por como termina el fichero 
00090         DATOS.elementos=num_line_total;                 
00091         file.close();           
00092         }
00093 
00094         
00095         if ( file.open( IO_ReadOnly ) ) 
00096         {       
00097         basicos *p_DATA=&DATOS;basicos *p_DATOS=&DATOS;
00098         int num_line=1;
00099         int esp_blnk;
00100         int cont=0;             
00101         QString valor,identifelemen;
00102         p_DATOS->tableMDG=tableMDG;p_DATOS->tableMN=tableMN;p_DATOS->tableMVC=tableMVC;
00103         p_DATOS->tablex0=tablex0;
00104 
00105         while ( !stream.atEnd() ) 
00106         {
00107                 for (i=0;i<num_line_total;i++)
00108                 {                                       
00109                 line = stream.readLine(); // linea de texto excluyendo el '\n'                          
00110                 //Es el número de veces que debo leer la linea 
00111                 int num_lecturas_linea=line.contains(' ', FALSE);               
00112                                 
00113                         if (num_line>1 && line!=".end")
00114                         {
00115                         bool result;    
00116                         int elemento=0;
00117                         esp_blnk = line.find( ' ' );
00118                         identifelemen = line.left( esp_blnk );
00119                         elemento= identifelemen.toInt(&result,10);                                      
00120                         lee_elemento (elemento,p_DATA);
00121                         p_DATOS->almacena_long_max(p_DATA->lim[2]);
00122                                 for(j=0;j<p_DATA->lim[2];j++)
00123                                 {                                               
00124                                 esp_blnk = line.find( ' ' );
00125                                         if(cont<num_lecturas_linea)
00126                                         {
00127                                         valor = line.left( esp_blnk );
00128                                         //insertar valor en la tabla adecuada
00129                                         if (j<p_DATA->lim[0]){tableMDG->setText(i,j,valor);}
00130                                         if (j<p_DATA->lim[1] && j>=p_DATA->lim[0])
00131                                         {tableMN->setText(i,(j-p_DATA->lim[0]), valor );}
00132                                         if (j<p_DATA->lim[2] && j>=p_DATA->lim[1])
00133                                         {tableMVC->setText(i,(j-p_DATA->lim[1]), valor );}      
00134                                         line.remove(0,esp_blnk+1);
00135                                         num_lecturas_linea=num_lecturas_linea+1;
00136                                         }
00137                                 }
00138                         }
00139                 num_line++;     
00140                 }
00141         }
00142         file.close();           
00143         }
00144 }

void sbcl_principal::slt_abrirps (  )  [virtual, slot]

Slot encargado de abrir la imagen del circuito para visualizar el mismo en pestaña Circuito.

Definición en la línea 204 del archivo sbcl_principal.cpp.

00205 {
00206 basicos *p_DATOS=&DATOS;
00207 QPixmap *imagen;
00208 QString nombre_imagen=p_DATOS->file_png;
00209 imagen=new QPixmap(nombre_imagen);
00210 pixmapLabel1_2->setPixmap(*imagen);
00211 }

void sbcl_principal::slt_xcircuit (  )  [virtual, slot]

Slot encargado de abrir el Xcircuit para realizar el diseño del circuito a través de la librería de elementos elaborada para Ávalon.

Definición en la línea 446 del archivo sbcl_principal.cpp.

00447 {
00448 if (!fork()){system("xcircuit");exit(1);}
00449 wait();
00450 }

void sbcl_principal::slt_analisis (  )  [virtual, slot]

Slot que se encarga de verificar que está seleccionado en tipo de análisis para así indicar a Ávalon como ha de comportarse en el análisis. Básicamente lo que hace es modificar los valores de unas variables en la clase basicos DATOS cuando el usuario cliquea en trasitorio o estacionario.

Definición en la línea 418 del archivo sbcl_principal.cpp.

00419 {
00420 basicos *p_DATOS;p_DATOS=&DATOS;
00421 QCheckBox *state=cb_trans;
00422 if(state->isChecked()){p_DATOS->transitorio=1;}
00423 QCheckBox *state2=cb_esta;
00424 if(state2->isChecked()){p_DATOS->estacionario=1;}
00425 }

void sbcl_principal::slt_solEstacionario ( basicos *  p_DATOS  )  [virtual, slot]

Este Slot se encarga de escribir en pantalla la solución del sistema estacionario.

Parámetros:
p_DATOS Puntero a estructura basicos

Definición en la línea 213 del archivo sbcl_principal.cpp.

00214 {
00215 p_DATOS->file_sol_permanente.replace( ".spc", ".data" );
00216 QStringList lines;
00217 QFile file( "sol_perm.data" );
00218     if ( file.open( IO_ReadOnly ) ) {
00219         QTextStream stream( &file );
00220         QString line;
00221        
00222        while ( !stream.atEnd() ) 
00223         {
00224                 line = stream.read();  
00225                 textEdit2->setText(line);
00226                 lines += line;
00227         }    
00228 
00229         file.close();
00230     }
00231 //system("rm sol_perm.data x_perm.data");
00232 }

void sbcl_principal::slt_calculadora (  )  [virtual, slot]

Este Slot se encarga de lanzar una calculadora para posibles cálculos que el usuario pueda necesitar.

Definición en la línea 458 del archivo sbcl_principal.cpp.

00459 {
00460 if (!fork()){system("kcalc");exit(1);}
00461 wait();
00462 }

void sbcl_principal::slt_prepara (  )  [virtual, slot]

Este slot se encarga preparar la tabla de condiciones iniciales Entre las tareas que realiza este slot se encuentra:
.

  • Preparar la tabla de Condiciones Iniciales calculando cuantas se deben introducir.
  • Escribir en pantalla las variables que calculará el sistema y por lo tanto las condiciones iniciales que deben introducirse.
  • Poner en la pestaña en la que se encuentra un gráfico del circuito para que el usuario se guíe mejor en la introducción de las CI
    Ver también:
    mostrar_CI

Definición en la línea 146 del archivo sbcl_principal.cpp.

00147 {
00148 basicos *p_DATOS=&DATOS;
00149 QPixmap *imagen;
00150 //Nos encargamos de preparar la tabla para las condiciones iniciales
00151 int *num_line_total_p=&DATOS.elementos;
00152 dimensiona(num_line_total_p,p_DATOS);
00153 mostrar_CI(p_DATOS);
00154 tablex0->insertRows(0,p_DATOS->filas());
00155 
00156 //Escritura en pantalla de las variables que se calcularan en el sistema
00157 QStringList lines;
00158 QFile file( "CI.data" );
00159 if ( file.open( IO_ReadOnly ) ) 
00160 {
00161 QTextStream stream( &file );
00162 QString line;
00163 while ( !stream.atEnd() ) 
00164         {
00165         line = stream.read();  
00166         textEdit2->setText(line);
00167         lines += line;
00168         }
00169 file.close();
00170 }
00171 system("rm CI.data");
00172 
00173 QString nombre_imagen=p_DATOS->file_png;
00174 imagen=new QPixmap(nombre_imagen);
00175 pixmapLabel1_2_2->setPixmap(*imagen);
00176 }

void sbcl_principal::slt_nuevoanalisis (  )  [virtual, slot]

Este slot se encarga purgar los valores necesarios para comenzar con un análisis de un nuevo circuito.

Definición en la línea 178 del archivo sbcl_principal.cpp.

00179 {
00180 
00181 //int num_filas=DATOS.elementos;
00182 int num_filas=tableMDG->numRows ();
00183 for (int k=0;k<5;k++){
00184 for(int i=0;i<=num_filas+1;i++)
00185 {tableMDG->removeRow (i);tableMN->removeRow (i);
00186 tableMVC->removeRow (i);tablex0->removeRow (i);}}
00187 DATOS.file_spc="";DATOS.file_sol_permanente="";
00188 DATOS.file_png="";DATOS.file_sol_permanente="";
00189 DATOS.datos_perm="";DATOS.datos_trans="";
00190 DATOS.datos_script="";DATOS.solucion="";DATOS.sol_trans="";DATOS.sol_perm="";
00191 DATOS.elementos=0; DATOS.EA=0; DATOS.nodos=0;DATOS.A2=0; 
00192 DATOS.estacionario=0; DATOS.transitorio=0;
00193 DATOS.h=0;DATOS.theta=0;DATOS.t0=0;DATOS.tf=0;DATOS.numv=0; DATOS.t=0;
00194 DATOS.densidad=0;DATOS.dispersion=0;DATOS.iter=0;DATOS.estaT=0;
00195 DATOS.apuntaEA=0;DATOS.apuntaA2=0;
00196 
00197 VecDestroy(DATOS.W);VecDestroy(DATOS.Wn);
00198 VecDestroy(DATOS.Wn1);VecDestroy(DATOS.x_perm);
00199 VecDestroy(DATOS.x_trans);
00200 VecDestroy(DATOS.xn);VecDestroy(DATOS.x0);
00201 MatDestroy(DATOS.T);MatDestroy(DATOS.G);MatDestroy(DATOS.C);
00202 }

void sbcl_principal::slt_gnuplot (  )  [virtual, slot]

Slot encargado de abrir el GNUPlot para realizar nuevos ploteos tras adaptar el script realizado por defecto.

Definición en la línea 452 del archivo sbcl_principal.cpp.

00453 {
00454 if (!fork()){system("konsole -e gnuplot");exit(1);}
00455 wait();
00456 }

void sbcl_principal::slt_sobreQt (  )  [virtual, slot]

Slot encargado de lanzar el diálogo de información de la versión de Qt utilizada.

Definición en la línea 475 del archivo sbcl_principal.cpp.

00476 {
00477   QMessageBox::aboutQt( this, "Intefaz creada con Qt" );
00478 }

void sbcl_principal::slt_ayuda (  )  [virtual, slot]

Slot encargado de abrir diálogo de información sobre el programa.

Definición en la línea 464 del archivo sbcl_principal.cpp.

00465 {
00466 
00467 
00468 QMessageBox::about( this, "Ayuda de Avalon",
00469 "PFC:\nSoftware de analisis de circuitos lineales\n"
00470 "mediante metodos avanzados de resolucion\npara uso docente\n\n"
00471 "Manual de usuario del programa\ny mas info disponibles""\n"
00472 "en la web http://avalon-alp.es");
00473 }

void sbcl_principal::slt_sistemaestacionario (  )  [virtual, slot]

Slot que carga el sistema a resolver del estacionario en pantalla.

Definición en la línea 480 del archivo sbcl_principal.cpp.

00481 {
00482 //Escritura en pantalla de las variables que se calcularan en el sistema
00483 QStringList lines;
00484 QFile file( "Datos_x_perm.data" );
00485     if ( file.open( IO_ReadOnly ) ) {
00486         QTextStream stream( &file );
00487         QString line;
00488        
00489        while ( !stream.atEnd() ) 
00490         {
00491                 line = stream.read();  
00492                 textEdit_sistemaestacionario->setText(line);
00493                 lines += line;
00494         }    
00495 
00496         file.close();
00497     }
00498 //system("rm Datos_x_perm.data");
00499 }

void sbcl_principal::slt_sistematransitorio (  )  [virtual, slot]

Slot que carga los sistemas a resolver del transitorio en pantalla.

Definición en la línea 501 del archivo sbcl_principal.cpp.

00502 {
00503 //Escritura en pantalla de las variables que se calcularan en el sistema
00504 QStringList lines;
00505 QFile file( "Datos_x_trans.data" );
00506     if ( file.open( IO_ReadOnly ) ) {
00507         QTextStream stream( &file );
00508         QString line;
00509        
00510        while ( !stream.atEnd() ) 
00511         {
00512                 line = stream.read();  
00513                 textEdit_sistematransitorio->setText(line);
00514                 lines += line;
00515         }    
00516 
00517         file.close();
00518     }
00519 //system("rm Datos_x_trans.data");
00520 }

void sbcl_principal::slt_solucionestacionario (  )  [virtual, slot]

Slot que carga la solución del estacionario en pantalla.

Definición en la línea 522 del archivo sbcl_principal.cpp.

00523 {
00524 //Escritura en pantalla de las variables que se calcularan en el sistema
00525 basicos *p_DATOS=&DATOS;
00526 QStringList lines;
00527 QFile file( p_DATOS->datos_perm );
00528     if ( file.open( IO_ReadOnly ) ) {
00529         QTextStream stream( &file );
00530         QString line;
00531        
00532        while ( !stream.atEnd() ) 
00533         {
00534                 line = stream.read();  
00535                 textEdit09_solucionestacionario->setText(line);
00536                 lines += line;
00537         }    
00538 
00539         file.close();
00540     }
00541 system("rm sol_perm.data");
00542 }

void sbcl_principal::slt_soluciontransitorio (  )  [virtual, slot]

Slot que carga la solución del transitorio en pantalla.

Definición en la línea 544 del archivo sbcl_principal.cpp.

00545 {
00546 //Escritura en pantalla de las variables que se calcularan en el sistema
00547 basicos *p_DATOS=&DATOS;
00548 QStringList lines;
00549 QFile file( p_DATOS->datos_trans );
00550     if ( file.open( IO_ReadOnly ) ) {
00551         QTextStream stream( &file );
00552         QString line;
00553        
00554        while ( !stream.atEnd() ) 
00555         {
00556                 line = stream.read();  
00557                 textEdit_soluciontransitorio->setText(line);
00558                 lines += line;
00559         }    
00560 
00561         file.close();
00562     }
00563 //system("rm sol_trans.data");
00564 }

void sbcl_principal::slt_cargagrafico (  )  [virtual, slot]

Este slot abre el gráfico realizado con el script por defecto en pantalla.

Definición en la línea 566 del archivo sbcl_principal.cpp.

00567 {
00568 basicos *p_DATOS=&DATOS;
00569 QString grafica = p_DATOS->solucion;
00570 grafica.prepend("kview ");
00571 if (!fork()){system(grafica);exit(1);}
00572 wait();
00573 }

void sbcl_principal::slt_abrescript (  )  [virtual, slot]

Este slot abre el script que usa GNUPlot para generar el gráfico final de las variables calculadas.

Definición en la línea 575 del archivo sbcl_principal.cpp.

00576 {
00577 basicos *p_DATOS=&DATOS;
00578 QString comando=script(p_DATOS);
00579 
00580 if (!fork()){system(comando);exit(1);}
00581 wait();
00582 }

void sbcl_principal::slt_vermatrizT (  )  [virtual, slot]

Este slot abre una visualización gráfica de la matriz sparse.

Definición en la línea 584 del archivo sbcl_principal.cpp.

00585 {
00586 basicos *p_DATOS=&DATOS;
00587 MatView(p_DATOS->T,PETSC_VIEWER_DRAW_WORLD );
00588 }

void sbcl_principal::INFOgeneral ( basicos *  DATOS  )  [virtual, slot]

Slot escargado de visualizar datos generales del circuito que se está analizando.

Definición en la línea 590 del archivo sbcl_principal.cpp.

00591 {       
00592 QString line;
00593 QString salto=("\n");
00594 int elementos=DATOS->elementos; 
00595 int EA=DATOS->EA; QString sEA("EA: ");
00596 int nodos=DATOS->nodos;QString sNodos("Nodos: ");
00597 int A2=DATOS->A2;QString sA2("A2: ");
00598 int NOnulos=DATOS->nocero;QString sNonulos("No nulos: ");
00599 double densidad=DATOS->densidad;QString sdensidad("Densidad: ");
00600 double dispersion=DATOS->dispersion;QString sdispersion("Dispersion: ");
00601 
00602 //Calculo de la densidad y dispersión de la matriz T
00603 MatInfo info;                   
00604 MatGetInfo(DATOS->T,MAT_LOCAL,&info);
00605 DATOS->nocero=info.nz_used;             
00606 DATOS->densidad=info.nz_used/(DATOS->filas()*DATOS->columnas());
00607 DATOS->dispersion=1-DATOS->densidad;
00608 
00609 line= QString("Elementos del Cto: ");
00610 QString valor,valor1,valor2,valor3,valor4,valor5,valor6;
00611 valor.setNum (elementos, 10);line.append(valor);line.append(salto);
00612 valor1.setNum (EA, 10);line.append(sEA);line.append(valor1);line.append(salto);
00613 valor2.setNum (nodos, 10);line.append(sNodos);line.append(valor2);line.append(salto);
00614 valor3.setNum (A2, 10);line.append(sA2);line.append(valor3);line.append(salto);
00615 valor4.setNum (NOnulos, 10);line.append(sNonulos);line.append(valor4);line.append(salto);
00616 valor5.setNum (densidad,'g', 6);
00617 line.append(sdensidad);line.append(valor5);line.append(salto);
00618 valor6.setNum (dispersion,'g', 10);
00619 line.append(sdispersion);line.append(valor6);line.append(salto);
00620 te_infogeneral->setText(line);
00621 }

Documentación de los datos miembro

basicos sbcl_principal::DATOS

Definición en la línea 35 del archivo sbcl_principal.h.

La documentación para esta estructura fue generada a partir de los siguientes ficheros:
Generado el Wed Sep 2 16:04:56 2009 para Software de Análisis de Circuitos Lineales mediante Métodos Avanzados de Resolución para Uso Docente. Manual de Código Fuente por  doxygen 1.5.6