Codice Sorgente.

Qui sono riportati i file di codice sorgente e i file Header delle unità che compongono il programma.
Si consiglia di vedere la  struttura  ed eventualmente anche le  note tecniche.  (torna all'indice).

Ogni Unità è composta dal file sorgente .cpp e dall' intestazione .h .
Le Form hanno in più il file .dfm, qui non incluso.
 

listati   Versione 0.95


 -----------------------------------
| Legenda
| grassetto : parole chiave
| verde : direttive al precompilatore
| blu : commenti
 -----------------------------------
 
 



***** Unit Datain ******************************

Datain.cpp ------------------------------------------------Torna Su

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop
#include "Datain.h"
#include "DataOk.h"
#include "Gauss.h"
#include "Newton.h"
#include "Info.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
 : TForm(Owner)
{
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
 void TForm1::CreaCaselle()  //costruisce le caselle editabili nella form 1
{
    /*costruzione form*/
int x,y;

/*label numeri nodo*/
for (x=0; x<maxnodi; x++)
    {
    labely[x] = new TLabel(this);
    labely[x]->Width = 20;
    labely[x]->Height = 20;
    labely[x]->Top = 85+20*x;
    labely[x]->Left = 15+50*x;
    //labely[x]->    =   ;
    labely[x]->Caption = x+1;
    InsertControl(labely[x]);

    labelx[x] = new TLabel(this);
    labelx[x]->Width = 20;
    labelx[x]->Height = 20;
    labelx[x]->Top = 65;
    labelx[x]->Left = 50+50*x;
    //labelx[x]->    =   ;
    labelx[x]->Caption = x+1;
    InsertControl(labelx[x]);

    labeld[x] = new TLabel(this);
    labeld[x]->Width = 20;
    labeld[x]->Height = 20;
    labeld[x]->Top = 85+20*x;
    labeld[x]->Left = 395;
    //labeld[x]->    =   ;
    labeld[x]->Caption = x+1;
    InsertControl(labeld[x]);
    }

/*caselle matrice ammettenze*/
for (y=0; y<maxnodi; y++)
     for (x=y; x<maxnodi; x++)
     {
     Caselley[x][y] = new TEdit(this);
     Caselley[x][y]->Width = 50;
     Caselley[x][y]->Height = 20;
     Caselley[x][y]->Top = 80+20*y;
     Caselley[x][y]->Left = 30+50*x;
     Caselley[x][y]->Text = "";
     //Caselley[x][y]->   =   ;
     InsertControl(Caselley[x][y]);
     }

/*caselle dati*/
for (y=0; y<maxnodi; y++)
     for (x=0; x<4; x++)
     {
     Caselled[x][y] = new TEdit(this);
     Caselled[x][y]->Width = 50;
     Caselled[x][y]->Height = 20;
     Caselled[x][y]->Top = 80+20*y;
     Caselled[x][y]->Left = 410+55*x;
     Caselled[x][y]->Text = "";
     //Caselled[x][y]->   =   ;
     InsertControl(Caselled[x][y]);
     }
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
  cplx TForm1::AnalizzatoreSintattico(String S)  //traduce le stringhe in numeri complessi
{
 cplx C;
    int s;
    int i;
    String T;
    String N;

    for (i=0; i<=S.Length(); i++) {
     if (S[i] != ' ') T += S[i];
    }

    i = 1;
    s = 1;
    if (T[i] == '+') i++;
    if (T[i] == '-') s = -1 , i++;
    N = "";
    if (T[i] == 'j') {
  C.Re = 0;
        C.Im = s;
        return C;
    }
    while (i <= T.Length() && (T[i] == '.' || (T[i]>='0' && T[i]<='9'))) N += T[i++];
    if (i <= T.Length() && T[i] == 'j') {
  C.Re = 0;
        C.Im = s * _atold(N.c_str());
        return C;
    }
 C.Re = s * _atold(N.c_str());
    C.Im = 0;
    if (i > T.Length()) return C;
    s = 1;
    if (T[i] == '+') i++;
 if (T[i] == '-') s = -1 , i++;
    N = "";
    if (T[i] == 'j') {
        C.Im = s;
        return C;
    }
    while (i <= T.Length() && (T[i] == '.' || (T[i]>='0' && T[i]<='9'))) N += T[i++];
    if (i <= T.Length() && T[i] == 'j') {
        C.Im = s * _atold(N.c_str());
        return C;
    }
 return C;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
String TForm1::Depur(String S)   //depura la stringa acquisita preparandola per la conversione
{
int i=0;
String T="";
while (i<=S.Length())
         {
         if (S[i]==',') S[i]=='.';
         if(S[i]=='.' || S[i]=='+' || S[i]=='-' || (S[i]>='0' && S[i]<='9')) T+=S[i];
         i++;
         }
return T;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{
CreaCaselle();
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//-----------ACQUISIZIONE DATI---------------------------------
void __fastcall TForm1::BtnAcquireClick(TObject *Sender)
{
 // chiusura eventuali sottoform
        Form2-> Close();
        Form3-> Close();
        Form4-> Close();

//___________Matrice__________Ammettenze___________

int i,j,p;

/*determinazione n° nodi controllando la diagonale*/
n=0;
while ((n<maxnodi)&&(Caselley[n][n]->Text != "")) n++;

/*controlli:segnalazione caselle piene fuori*/
for (j=0 ; j<n ; j++)
     for (i=n ; i<maxnodi ; i++)
        if (Caselley[i][j]->Text != "") {
            Segnalazione(0);
           return;
        }

for (j=n ; j<maxnodi ; j++)
     for (i=j ; i<maxnodi ; i++)
        if (Caselley[i][j]->Text != "") {
            Segnalazione(0);
           return;
        }
 

/*conversione e completamento automatico delle caselle vuote (vengono poste a 0)*/
for (j=0 ; j<n ; j++)
     for (i=j ; i<n ; i++)
       {
        if (Caselley[i][j]->Text=="") {
                                       Yc[i][j].Re=0;
                                       Yc[i][j].Im=0;
                                       Yc[j][i]=Yc[i][j];
                              continue;
                                       }

        Yc[i][j]=AnalizzatoreSintattico(Caselley[i][j]->Text);
        Yc[j][i]=Yc[i][j];
       }

/*creazione delle matrici moduli e fasi delle ammettenze*/
for (i=0 ; i<n ; i++)
     for (j=0 ; j<n ; j++)
       {
       Y[i][j]=mod(Yc[i][j]);
       th[i][j]=arg(Yc[i][j]);
       }
 

 //__________vettori_____________dati________________________

bool datacon[4][maxnodi];  //matrice dati conosciuti
String N;

/*controllo caselle piene fuori dalle dimensioni*/
 for (i=0 ; i<4 ; i++)
     for (j=n ; j<maxnodi ; j++) if (Caselled[i][j]->Text!="") { Segnalazione(1); return; }

/*costruzione matrici valori e conoscienza*/
 for (i=0 ; i<4; i++)
     for (j=0 ; j<n ; j++)
          {
          if (Caselled[i][j]->Text=="") {datacon[i][j]=0;   //dato non conosciuto
                                        //inizializzazione dato non conosciuto
                                         if (i==2) dataval[i][j]=1;
                                else if (i==3) dataval[i][j]=0;
                                else dataval[i][j]=0;
                                continue;
                                        }
          N=Depur(Caselled[i][j]->Text);
          if (N=="") {datacon[i][j]=0;   //dato non conosciuto
                      //inizializzazione dato non conosciuto
             if (i==2) dataval[i][j]=1;
             else if (i==3) dataval[i][j]=0;
             else dataval[i][j]=0;
             continue;
                     }
          dataval[i][j]=_atold(N.c_str());
          datacon[i][j]=1;
          }
//conversione degli angoli in radianti...
for(p=0 ; p<n ; p++)  dataval[3][p]*=pi/180;

//_________Determinazione_dei_tipi_di_nodo___________________________

 /*controllo nodi non previsti*/
 int sum;
 for (j=0 ; j<n ; j++)
   {
    sum=0;
    for (i=0 ; i<4 ; i++) sum+=datacon[i][j];
    if (sum!=2) { Segnalazione(2); return; }
   }
/*assegnazione tipo*/
 for (i=0 ; i<n ; i++)
    {
    if (datacon[2][i]&&datacon[3][i]) {tiponodo[i]= Ed; continue;}
    if (datacon[0][i]&&datacon[1][i]) {tiponodo[i]= PQ; continue;}
    if (datacon[0][i]&&datacon[2][i]) {tiponodo[i]= PE; continue;}
    if (datacon[0][i]&&datacon[3][i]) {tiponodo[i]= Pd; continue;}
    if (datacon[1][i]&&datacon[2][i]) {tiponodo[i]= QE; continue;}
    if (datacon[1][i]&&datacon[3][i]) {tiponodo[i]= Qd; continue;}
    }
 

//___Costruzione_degli_Arrays_di_supporto_per_il_calcolo_dello_Jacobiano____
i=0;
j=0;

//primo giro:equazioni in P e incognite E
for (p=0 ; p<n ; p++)  switch (tiponodo[p])
                              {
                    case PQ : {
                                         Jeq[i++]=p;
                                         Jinc[j++]=p;
                                         break;
                                         }
                    case Pd : {
                                         Jeq[i++]=p;
                                         Jinc[j++]=p;
                                         break;
                                         }
                    case PE : {
                                         Jeq[i++]=p;
                                         break;
                                         }
                    case Qd : {
                                         Jinc[j++]=p;
                                         break;
                                         }
                               }

nP=i; //numero equazioni in P
nE=j; //numero di incognite E

//secondo giro:equazioni in Q e incognite d
for (p=0 ; p<n ; p++) switch (tiponodo[p])
                             {
                      case PQ : {
                                           Jeq[i++]=p;
                                           Jinc[j++]=p;
                                           break;
                                          }
                      case QE : {
                                           Jeq[i++]=p;
                                           Jinc[j++]=p;
                                           break;
                                         }
                      case Qd : {
                                           Jeq[i++]=p;
                                           break;
                                          }
                      case PE : {
                                           Jinc[j++]=p;
                                           break;
                                          }
                              }

ord=j;     // ordine del sistema
if (ord!=i) { Segnalazione(3); return; }

/*Chiamata unit Dataok per visualizzazione risultati...*/

    Form2->Risultati();
    Form2->Show();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BtnClearClick(TObject *Sender)
{
  for (int x=0; x<maxnodi; x++)
      for (int y=0; y<x+1; y++)  Caselley[x][y]->Text ="";

  for (int x=0; x<4; x++)
      for (int y=0; y<maxnodi; y++) Caselled[x][y]->Text ="";
}
//---------------------------------------------------------------------------
// aiuto veloce
void __fastcall TForm1::Label2Click(TObject *Sender)
{
Application->MessageBox("Iniezioni di potenza attiva\n\n\
                         In questa colonna vanno inseriti i valori in  pu  (rispetto ad una\n\
                         potenza trifase arbitraria ma costante) delle iniezioni di potenza\n\
                         attiva nodali note e imposte alla rete , considerate positive se\n\
                         entranti (nodi generatori),negative se uscenti (nodi utilizzatori).\n\
                         Nei nodi di interconnessione pura  esse sono nulle (e quindi note).\n\n\
                         Campo di valori P : numeri reali , il cui valore assoluto\n\
                                                       è intorno alle unità (se il riferimento\n\
                                                       è opportuno).\n\n\n\
                         Informazioni aggiuntive:\n\n\
                         Quando non si conosce l'iniezione (questo avviene per nodi Ed,QE,         \n\
                         Qd) basta lasciare vuota la casella.\n\
                         Si tenga presente che per il corretto funzionamento del programma\n\
                         ogni nodo deve avere rigorosamente due grandezze nodali note\n\
                         per poter essere classificato tra i sei tipi di nodi previsti:\n\n\
                            0-Ed  1-PQ  2-PE  3-Pd  4-QE  5-Qd\n","Tip",MB_ICONINFORMATION);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Label3Click(TObject *Sender)
{
Application->MessageBox("Iniezioni di potenza reattiva\n\n\
                         In questa colonna vanno inseriti i valori in  pu  (rispetto ad una\n\
                         potenza trifase arbitraria ma costante) delle iniezioni di potenza\n\
                         reattiva nodali note e imposte alla rete , considerate positive se\n\
                         entranti e induttive (o uscenti e capacitive),negative se entranti\n\
                         e capacitive (o uscenti e induttive).\n\
                         Nei nodi di interconnessione pura  esse sono nulle (e quindi note).\n\n\
                         Campo di valori Q : numeri reali , il cui valore assoluto\n\
                                                       è intorno alle unità (se il riferimento\n\
                                                       è opportuno).\n\n\n\
                         Informazioni aggiuntive:\n\n\
                         Quando non si conosce l'iniezione (questo avviene per nodi Ed,PE,           \n\
                         Pd) basta lasciare vuota la casella.\n\
                         Si tenga presente che per il corretto funzionamento del programma\n\
                         ogni nodo deve avere rigorosamente due grandezze nodali note\n\
                         per poter essere classificato tra i sei tipi di nodi previsti:\n\n\
                             0-Ed  1-PQ  2-PE  3-Pd  4-QE  5-Qd\n","Tip",MB_ICONINFORMATION);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Label4Click(TObject *Sender)
{
Application->MessageBox("Moduli delle tensioni nodali\n\n\
                         In questa colonna vanno inseriti i valori in pu (di solito rispetto alla tensione\n\
                         concatenata delle varie sezioni di rete)  dei moduli delle tensioni nodali noti\n\
                         e imposti alla rete.\n\n\
                         Campo di valori di E: numeri reali positivi,\n\
                                                          vicini all'unità.\n\n\n\
                         Informazioni aggiuntive:\n\n\
                         Quando non si conosce il valore (questo avviene per nodi PQ,Pd,Qd) basta lasciare\n\
                         vuota la casella; si tenga presente che per il corretto funzionamento del programma         \n\
                         ogni nodo deve avere rigorosamente due grandezze nodali note per poter essere\n\
                         classificato tra i sei tipi di nodi previsti:\n\n\
                               0-Ed  1-PQ  2-PE  3-Pd  4-QE  5-Qd\n","Tip",MB_ICONINFORMATION);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Label5Click(TObject *Sender)
{
Application->MessageBox("Fasi delle tensioni nodali\n\n\
                         In questa colonna vanno inseriti i valori noti e imposti alla rete delle fasi\n\
                         delle tensioni nodali.\n\n\
                         Campo di valori di d: numeri reali,solitamente\n\
                                                          nell'intorno dell'origine.\n\n\
                         Unità di misura: gradi.\n\n\n\
                         Informazioni aggiuntive:\n\n\
                         Quando non si conosce il valore (questo avviene per nodi PQ,PE,QE) basta lasciare\n\
                         vuota la casella; si tenga presente che per il corretto funzionamento del programma          \n\
                         ogni nodo deve avere rigorosamente due grandezze nodali note per poter essere\n\
                         classificato tra i sei tipi di nodi previsti:\n\n\
                              0-Ed  1-PQ  2-PE  3-Pd  4-QE  5-Qd\n","Tip",MB_ICONINFORMATION);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Label1Click(TObject *Sender)
{
Application->MessageBox("Matrice delle ammettenze nodali\n\n\
                         In queste caselle vanno inseriti gli elementi della matrice delle ammettenze nodali.               \n\
                         Si puntualizza che questa matrice è strettamente legata alla numerazione dei nodi\n\
                         ed è determinabile mediante ispezione della rete servendosi di semplici regole.\n\
                         Come tutte le altre grandezze in gioco , anche gli elementi di questa matrice sono\n\
                         intesi in valore relativo (pu=PerUnit).\n\
                         In generale gli elementi di questa matrice sono numeri complessi.\n\
                         Bisogna immettere questi valori con la seguente rigida sintassi:\n\n\
                         <SEGNO><PARTE REALE><SEGNO><PARTE IMMAGINARIA>J\n\n\
                         Gli eventuali  spazi  vuoti  nell' espressione sono ignorati ; se la parte reale è\n\
                         positiva  si può omettere  il segno +; nel caso che una componente sia nulla\n\
                         la si omette direttamente.\n\
                         Esempio di immissioni corrette:\n\n\
                         1,23 + 0,37 J\n\
                         -3,21 - 2 J\n\
                         1\n\
                         +5\n\
                         - J\n\n\
                         Campo di valori:\n\
                         per reti induttive ben costruite (resistenze piccole rispetto alle reattanze) si hanno\n\
                         di solito sulla diagonale principale  parti reali positive piccole e parti immaginarie\n\
                         negative dell'ordine delle decine ; nel resto della matrice si hanno valori nulli per\n\
                         i nodi non collegati,altrimenti parti reali negative piccole e parti immaginarie positive\n\
                         sempre dell'ordine delle decine.\n\n\n\
                         Informazioni aggiuntive:\n\n\
                         Le caselle lasciate vuote vengono considerate nulle ad eccezione di quelle sulla\n\
                         diagonale principale : il numero di nodi viene determinato controllando il primo\n\
                         elemento nullo sulla diagonale principale,per cui quanto trovato dopo viene\n\
                         scartato (il programma genera una segnalazione).","INSERIMENTO ELEMENTI MATRICE AMMETTENZE NODALI",MB_ICONINFORMATION);
}
//---------------------------------------------------------------------------
//bottone esci
void __fastcall TForm1::spdbtnExitClick(TObject *Sender)
{
    Form2->Close ();
    Form3->Close ();
    Form4->Close ();
    Close ();
}
//---------------------------------------------------------------------------
//salvataggio
void __fastcall TForm1::spdbtnSaveClick(TObject *Sender)
{
    if (!SaveDialog->Execute()) return;

    try {        //gestione delle eccezioni
        FILE * f = fopen (SaveDialog->FileName.c_str(), "w");

        for (int x=0; x<maxnodi; x++)
           for (int y=0; y<x+1; y++)
                if (Caselley[x][y]->Text == "")
                    fprintf (f, "\n");
           else
                    fprintf (f, "%s\n", Caselley[x][y]->Text.c_str());
        for (int x=0; x<maxnodi; x++)
           for (int y=0; y<4; y++)
           if (Caselled[y][x]->Text == "")
                    fprintf (f, "\n");
           else
                    fprintf (f, "%s\n", Caselled[y][x]->Text.c_str());

        fclose (f);
    }
    catch (Exception *) {
        Application->MessageBox ("Impossibile portare a termine il salvataggio.", "Errore", MB_ICONSTOP);
    }
}
//---------------------------------------------------------------------------
// apertura file
void __fastcall TForm1::spbtnOpenClick(TObject *Sender)
{
    if (!OpenDialog->Execute()) return;
    char buffer[100];

    try {    //gestione delle eccezioni
        FILE * f = fopen (OpenDialog->FileName.c_str(), "r");

        for (int x=0; x<maxnodi; x++)
           for (int y=0; y<x+1; y++)  {
                fgets (buffer, 100, f);
                buffer[strlen(buffer)-1] = 0;
                Caselley[x][y]->Text = buffer;
            }
        for (int x=0; x<maxnodi; x++)
           for (int y=0; y<4; y++) {
                fgets (buffer, 100, f);
                buffer[strlen(buffer)-1] = 0;
                Caselled[y][x]->Text = buffer;
            }

        fclose (f);

        Form2-> Close();
        Form3-> Close();
        Form4-> Close();
        }
    catch (Exception *) {
        Application->MessageBox ("Impossibile portare a termine la lettura.", "Errore", MB_ICONSTOP);
    }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::spdbtnCopyClick(TObject *Sender)
{
    TEdit * E = dynamic_cast <TEdit*> (ActiveControl);
    if (!E) return;
    E->CopyToClipboard();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::spdbtnCutClick(TObject *Sender)
{
    TEdit * E = dynamic_cast <TEdit*> (ActiveControl);
    if (!E) return;
    E->CutToClipboard();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::spdbtnPasteClick(TObject *Sender)
{
    TEdit * E = dynamic_cast <TEdit*> (ActiveControl);
    if (!E) return;
    E->PasteFromClipboard();
}
//---------------------------------------------------------------------------
// apertura file HTM alla directory   /../help/help.htm
void __fastcall TForm1::spdbtnHelpClick(TObject *Sender)
{
    String Path = Application->ExeName;
    int l = Path.Length();

//modifica percorso da ..\loadflow.exe  a  ..\help\help.htm
    Path[l-11] = 'H';
    Path[l-10] = 'E';
    Path[l-9] = 'L';
    Path[l-8] = 'P';
    Path[l-7] = '\\';
    Path[l-6] = 'H';
    Path[l-5] = 'E';
    Path[l-4] = 'L';
    Path[l-3] = 'P';
    Path[l-2] = '.';
    Path[l-1] = 'H';
    Path[l]  =  'T';
    Path+="M";
 ShellExecute(
     this->Handle, // handle to parent window
     "open", // pointer to string that specifies operation to perform
     Path.c_str(), // pointer to filename or folder name string
     0, // pointer to string that specifies executable-file parameters
     0, // pointer to string that specifies default directory
     SW_MAXIMIZE  // whether file is shown when opened
 );
}
//---------------------------------------------------------------------------
// apertura finestra informazioni su...
void __fastcall TForm1::spdbtnAboutClick(TObject *Sender)
{
About->ShowModal();
}
//---------------------------------------------------------------------------



Datain.h--------------------------------------------------Torna Su

//---------------------------------------------------------------------------
#ifndef DatainH
#define DatainH
//---------------------------------------------------------------------------
#include "Globalvar.h"
#include <vcl\Classes.hpp>
#include <vcl\Controls.hpp>
#include <vcl\StdCtrls.hpp>
#include <vcl\Forms.hpp>
#include <vcl\Menus.hpp>
#include <vcl\ExtCtrls.hpp>
#include <vcl\Buttons.hpp>
#include <vcl\Dialogs.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
 TLabel *Label1;
 TLabel *Label2;
 TLabel *Label3;
 TLabel *Label4;
 TLabel *Label5;
 TButton *BtnAcquire;
 TButton *BtnClear;

 TPanel *SpeedBar;
 TSpeedButton *spbtnOpen;
 TSpeedButton *spdbtnSave;
 TSpeedButton *spdbtnExit;
 TSpeedButton *spdbtnCut;
 TSpeedButton *spdbtnCopy;
 TSpeedButton *spdbtnPaste;
 TSpeedButton *spdbtnHelp;
 TSpeedButton *spdbtnAbout;
 TMainMenu *MainMenu;
 TMenuItem *FileMenu;
 TMenuItem *FileOpenItem;
 TMenuItem *FileSaveAsItem;
 TMenuItem *N4;
 TMenuItem *FileExitItem;
 TMenuItem *EditMenu;
 TMenuItem *EditCutItem;
 TMenuItem *EditCopyItem;
 TMenuItem *EditPasteItem;
 TMenuItem *HelpMenu;
 TMenuItem *HelpContentsItem;
 TMenuItem *N3;
 TMenuItem *HelpAboutItem;
 TOpenDialog *OpenDialog;
 TSaveDialog *SaveDialog;
 void __fastcall FormCreate(TObject *Sender);
    void __fastcall BtnAcquireClick(TObject *Sender);
    void __fastcall BtnClearClick(TObject *Sender);
    void __fastcall Label2Click(TObject *Sender);
 void __fastcall Label3Click(TObject *Sender);
 void __fastcall Label4Click(TObject *Sender);
 void __fastcall Label5Click(TObject *Sender);
 void __fastcall Label1Click(TObject *Sender);
    void __fastcall spdbtnExitClick(TObject *Sender);
    void __fastcall spdbtnSaveClick(TObject *Sender);
    void __fastcall spbtnOpenClick(TObject *Sender);
    void __fastcall spdbtnCopyClick(TObject *Sender);
    void __fastcall spdbtnCutClick(TObject *Sender);
    void __fastcall spdbtnPasteClick(TObject *Sender);
    void __fastcall spdbtnHelpClick(TObject *Sender);
 void __fastcall spdbtnAboutClick(TObject *Sender);
private: // User declarations
cplx Yc[maxnodi][maxnodi];  //matrice ammettenze complessa
/*controlli*/
TEdit *Caselley[maxnodi][maxnodi];
TEdit *Caselled[4][maxnodi];
TLabel *labely[maxnodi],*labelx[maxnodi];
TLabel *labeld[maxnodi],*labelv[4];
/*funzioni private*/
void CreaCaselle();
cplx AnalizzatoreSintattico(String);
String Depur(String);

public:  // User declarations
 __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern TForm1 *Form1;
//---------------------------------------------------------------------------
#endif


***** Unit Dataok ******************************

Dataok.cpp ----------------------------------------------Torna Su

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop
#include "Dataok.h"
#include "Globalvar.h"
#include "Gauss.h"
#include "Newton.h"

//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm2 *Form2;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
 : TForm(Owner)
{
}
//---------------------------------------------------------------------------
// scrittura dati nella listbox
void TForm2::Risultati () {
    TListItem * item;
    ListView->Items->Clear();

    for (int i=0; i<n; i++) {
        item = ListView->Items->Add();
        item->Caption = i+1;
        switch (tiponodo[i]) {
           case 0 : item->SubItems->Add ("Ed"); break;
           case 1 : item->SubItems->Add ("PQ"); break;
           case 2 : item->SubItems->Add ("PE"); break;
           case 3 : item->SubItems->Add ("Pd"); break;
           case 4 : item->SubItems->Add ("QE"); break;
           case 5 : item->SubItems->Add ("Qd"); break;
        }
        item->SubItems->Add (dataval[2][i]);
        item->SubItems->Add (dataval[3][i]);
        item->SubItems->Add (dataval[0][i]);
        item->SubItems->Add (dataval[1][i]);
    }
}
//---------------------------------------------------------------------------
// click del bottone "altra acquisizione"
void __fastcall TForm2::btnErrataClick(TObject *Sender)
{
    Close();
    Form3-> Close();
    Form4-> Close();
}
//---------------------------------------------------------------------------
// click del bottone "Gauss"
void __fastcall TForm2::btnGaussClick(TObject *Sender)
{
    Form3->Show();
}
//---------------------------------------------------------------------------
// click del bottone "Newton"
void __fastcall TForm2::btnNewtonClick(TObject *Sender)
{
    Form4->Show();
}
//---------------------------------------------------------------------------



Dataok.h -------------------------------------------------Torna Su

//---------------------------------------------------------------------------
#ifndef DataokH
#define DataokH
//---------------------------------------------------------------------------
#include "Globalvar.h"
#include <vcl\Classes.hpp>
#include <vcl\Controls.hpp>
#include <vcl\StdCtrls.hpp>
#include <vcl\Forms.hpp>
#include <vcl\ComCtrls.hpp>
//---------------------------------------------------------------------------
class TForm2 : public TForm
{
__published: // IDE-managed Components
 TButton *btnGauss;
 TButton *btnErrata;
 TButton *btnNewton;
    TListView *ListView;
    void __fastcall btnErrataClick(TObject *Sender);
    void __fastcall btnGaussClick(TObject *Sender);
    void __fastcall btnNewtonClick(TObject *Sender);
private: // User declarations
public// User declarations
 __fastcall TForm2(TComponent* Owner);
    void Risultati ( );
};
//---------------------------------------------------------------------------
extern TForm2 *Form2;
//---------------------------------------------------------------------------
#endif


***** Unit Gauss ******************************

Gauss.cpp -----------------------------------------------Torna Su

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop

#include "Gauss.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"

TForm3 *Form3;

//----------------------------------------------------------------------------
/*variabili visibili da tutte le funzioni dell'unità*/
double E[maxnodi][numit+1]; //moduli tensioni nodali
double d[maxnodi][numit+1]; //fasi tensioni nodali
int k;  //iterazione

//----------------------------------------------------------------------------
cplx GlimmStagg(int p)   //dato il nodo p,con le sue iniezioni e il
{                                           //profilo di tensioni precedente calcola la
 double sum=0;                  //nuova tensione in p con la forma canonica di
 int q;                                   //Glimm-Stagg espressa in forma polare.
 cplx C={0,0};

 for(q=0 ; q<p ; q++) sum+=Y[p][q]*E[q][k+1]*cos(d[q][k+1]+th[p][q]-th[p][p]);
 for(q=p+1 ; q<n ; q++) sum+=Y[p][q]*E[q][k]*cos(d[q][k]+th[p][q]-th[p][p]);
 C.Re=(((dataval[0][p]*cos(d[p][k]-th[p][p]))+(dataval[1][p]*sin(d[p][k]-th[p][p])))/E[p][k])-sum;
 sum=0;
 for(q=0 ; q<p ; q++) sum+=Y[p][q]*E[q][k+1]*sin(d[q][k+1]+th[p][q]-th[p][p]);
 for(q=p+1 ; q<n ; q++) sum+=Y[p][q]*E[q][k]*sin(d[q][k]+th[p][q]-th[p][p]);
 C.Im=(((dataval[0][p]*sin(d[p][k]-th[p][p]))-(dataval[1][p]*cos(d[p][k]-th[p][p])))/E[p][k])-sum;
 return C;
}
//---------------------------------------------------------------------------

/*procedura nodo di saldo*/
void fEd(int p)
{
E[p][k+1]=E[p][k];
d[p][k+1]=d[p][k];
}

/*procedura nodo PQ*/
void fPQ(int p)
{
cplx Ec;
Ec=GlimmStagg(p);
E[p][k+1]=mod(Ec)/Y[p][p];
d[p][k+1]=arg(Ec);
}

/*procedura nodo PE*/
void fPE(int p)
{
//stima dell'iniezione reattiva
double Q=0;
int q;
for(q=0 ; q<p ; q++)  Q+=Y[p][q]*E[q][k+1]*sin(d[p][k]-d[q][k+1]-th[p][q]);
for(q=p ; q<n ; q++)  Q+=Y[p][q]*E[q][k]*sin(d[p][k]-d[q][k]-th[p][q]);
dataval[1][p]=E[p][k]*Q;
//nuova tensione
E[p][k+1]=E[p][k];
d[p][k+1]=arg(GlimmStagg(p));
}

/*procedura nodo Pd*/
void fPd(int p)
{
//stima dell'iniezione reattiva
double Q=0;
int q;
for(q=0 ; q<p ; q++)   Q+=Y[p][q]*E[q][k+1]*sin(d[p][k]-d[q][k+1]-th[p][q]);
for(q=p ; q<n ; q++)   Q+=Y[p][q]*E[q][k]*sin(d[p][k]-d[q][k]-th[p][q]);
dataval[1][p]=E[p][k]*Q;
//nuova tensione
E[p][k+1]=mod(GlimmStagg(p))/Y[p][p];
d[p][k+1]=d[p][k];
}

/*procedura nodo QE*/
void fQE(int p)
{
//stima dell'iniezione attiva
double P=0;
int q;
for(q=0 ; q<p ; q++)   P+=Y[p][q]*E[q][k+1]*cos(d[p][k]-d[q][k+1]-th[p][q]);
for(q=p ; q<n ; q++)   P+=Y[p][q]*E[q][k]*cos(d[p][k]-d[q][k]-th[p][q]);
dataval[0][p]=E[p][k]*P;
//nuova tensione
E[p][k+1]=E[p][k];
d[p][k+1]=arg(GlimmStagg(p));
}

/*procedura nodo Qd*/
void fQd(int p)
{
//stima dell'iniezione attiva
double P=0;
int q;
for(q=0 ; q<p ; q++)   P+=Y[p][q]*E[q][k+1]*cos(d[p][k]-d[q][k+1]-th[p][q]);
for(q=p ; q<n ; q++)   P+=Y[p][q]*E[q][k]*cos(d[p][k]-d[q][k]-th[p][q]);
dataval[0][p]=E[p][k]*P;
//nuova tensione
E[p][k+1]=mod(GlimmStagg(p))/Y[p][p];
d[p][k+1]=d[p][k];
}
//---------------------------------------------------------------------------
__fastcall TForm3::TForm3(TComponent* Owner)
 : TForm(Owner)
{
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TForm3::FormShow(TObject *Sender)
{
//Gauss Seidel
int i,j;

/*preparazione valori iniziali*/
for (i=0 ; i<n ; i++)
    {
    E[i][0]=dataval[2][i];
    d[i][0]=dataval[3][i];
    }
//array puntatori a funzione
void (*pfunct[6])(int);
/*inizializzazione array puntatori a funzione*/
pfunct[0]= fEd;
pfunct[1]= fPQ;
pfunct[2]= fPE;
pfunct[3]= fPd;
pfunct[4]= fQE;
pfunct[5]= fQd;

//algoritmo Gauss
for(k=0 ; k<numit ; k++)
    for(int p=0 ; p<n ; p++)  pfunct[tiponodo[p]](p);

//Calcolo terminato;conversione delle fasi in gradi...
for(i=0 ; i<n ; i++)
   for(j=0 ; j<numit+1 ; j++)
       {
       d[i][j] *= 180/pi;
       }

//visualizzazione risultati sulla form 3...

TListItem * item;
ListView->Items->Clear();

for (j=0; j<numit+1; j++)
    {
    for (i=0; i<n; i++)
        {
        item = ListView->Items->Add();
        item->Caption = j;
        item->SubItems->Add(i+1);
        item->SubItems->Add(E[i][j]);
        item->SubItems->Add(d[i][j]);
        }
    ListView->Items->Add();
    ListView->Items->Add();
    ListView->Items->Add();
    }
}
//---------------------------------------------------------------------------



Gauss.h ---------------------------------------------------Torna Su

//---------------------------------------------------------------------------
#ifndef GaussH
#define GaussH
//---------------------------------------------------------------------------
#include "Globalvar.h"
#include <vcl\Classes.hpp>
#include <vcl\Controls.hpp>
#include <vcl\StdCtrls.hpp>
#include <vcl\Forms.hpp>
#include <vcl\ComCtrls.hpp>
//---------------------------------------------------------------------------
class TForm3 : public TForm
{
__published: // IDE-managed Components
    TListView *ListView;
    void __fastcall FormShow(TObject *Sender);

private: // User declarations
public:  // User declarations
 __fastcall TForm3(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern TForm3 *Form3;
//---------------------------------------------------------------------------
#endif


***** Unit Newton ******************************

Newton.cpp ----------------------------------------------Torna Su

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop

#include "Newton.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"

TForm4 *Form4;

//---------------------------------------------------------------------------
/*variabili visibili da tutte le funzioni dell'unità*/
double E[maxnodi][numit+1],d[maxnodi][numit+1]; //moduli e fasi tensioni nodali
double J[2*maxnodi][2*maxnodi]; //jacobiano
double Jinv[2*maxnodi][2*maxnodi]; //inversa dello jacobiano
double res[2*maxnodi];   //residuo delle potenze
double incr[2*maxnodi];  //vettore incrementi incognite
int k;   //iterazione

//---------------------------------------------------------------------------
__fastcall TForm4::TForm4(TComponent* Owner)
 : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void TForm4::CalcoloResiduo()
{
 int e,q;    //equazione, nodo
 //residuo attivo
 for(e=0 ; e<nP ; e++)
     {
     res[e]=0;
     for(q=0 ; q<n ; q++) res[e]+=Y[Jeq[e]][q]*E[q][k]*cos(d[Jeq[e]][k]-d[q][k]-th[Jeq[e]][q]);
     res[e]=dataval[0][Jeq[e]]-(E[Jeq[e]][k]*res[e]);
     }
 //residuo reattivo
 for(e=nP ; e<ord ; e++)
     {
     res[e]=0;
     for(q=0 ; q<n ; q++) res[e]+=Y[Jeq[e]][q]*E[q][k]*sin(d[Jeq[e]][k]-d[q][k]-th[Jeq[e]][q]);
     res[e]=dataval[1][Jeq[e]]-(E[Jeq[e]][k]*res[e]);
     }
}
//---------------------------------------------------------------------------
void TForm4::CalcoloJacobiano()
{
//lo si calcola a blocchi-struttura:  |PE Pd|
//                                                        |QE Qd|
int i,j;
/*blocchi PE e Pd*/
for(i=0 ; i<nP ; i++)
     {
     for(j=0 ; j<nE ; j++)     J[i][j]=dPdE(Jeq[i],Jinc[j]);
     for(j=nE ; j<ord ; j++)   J[i][j]=dPdd(Jeq[i],Jinc[j]);
     }

/*blocchi PE e Pd*/
for(i=nP ; i<ord ; i++)
     {
     for(j=0 ; j<nE ; j++)     J[i][j]=dQdE(Jeq[i],Jinc[j]);
     for(j=nE ; j<ord ; j++)   J[i][j]=dQdd(Jeq[i],Jinc[j]);
     }
}
//---------------------------------------------------------------------------
void TForm4::CalcoloInversa()
{
/*Inversione di matrice double*/
//J è la matrice da invertire,ord il suo ordine
// dichiarazioni
 int i,j,h,temp;
 int ind[2*maxnodi];  /*array delle permutazioni: lega gli indici delle righe della matrice non permutata con quelli della matrice permutata*/
 double somm;
 double lowupp[2*maxnodi][2*maxnodi]; //matrici lower e upper condensate
 double y[2*maxnodi];  //vettore intermedio di supporto dei calcoli
 double I[2*maxnodi][2*maxnodi]; //matrice identità
 

// Inizializzazioni e costruzione matrice unità
 for (i=0 ; i<2*maxnodi ; i++)
        {
         y[i]=0;
         ind[i]=i;
        for (j=0 ; j<2*maxnodi ; j++)
               {
        if (i==j) I[i][i]=1;
        else I[i][j]=0;
               lowupp[i][j]=0;
               Jinv[i][j]=0;
               }
        }

//Pivoting: permutazione delle righe per non incorrere in errori numerici.
//Costruzione array delle permutazioni
for (i=0 ; i<ord ; i++)
     for (j=i+1 ; j<ord ; j++)
     if ( fabs(J[i][i]) < fabs(J[ind[j]][i]) )   {
                                                                    temp=ind[i];
                                                                    ind[i]=ind[j];
                                                                    ind[j]=temp;
                                                                    }

//parte 1: fattorizzazione per righe
 for(i=0 ; i<ord ; i++) //per ogni riga
     {
     for(j=0 ; j<i ; j++)        //matrice Lower
                    {
                    somm=0;
           for(h=0 ; h<j ; h++)  somm += lowupp[i][h]*lowupp[h][j];
                    lowupp[i][j] = (J[ind[i]][j]-somm)/lowupp[j][j];
                    }
     for(j=i ; j<ord ; j++)        //matrice Upper
                    {
                    somm=0;
           for(h=0 ; h<i ; h++)  somm += lowupp[i][h]*lowupp[h][j];
                    lowupp[i][j] = (J[ind[i]][j]-somm);
                    }
     }
 //parte 2: inversione per colonne
 for(j=0 ; j<ord ; j++) //per ogni colonna
     {
     for(i=0 ; i<ord ; i++)        //vettore intermedio risolvendo in avanti
                    {
                    somm=0;
           for(h=0 ; h<i ; h++)  somm += lowupp[i][h]*y[h];
                    y[i]= I[ind[i]][j]-somm ;
                    }
     for(i=0 ; i<ord ; i++)        //colonna dell'inversa risolvendo all'indietro
                    {
                    somm=0;
           for(h=0 ; h<i ; h++)  somm += lowupp[ord-1-i][ord-1-h]*Jinv[ord-1-h][j];
                    Jinv[ord-1-i][j] = (y[ord-1-i]-somm)/lowupp[ord-1-i][ord-1-i];
                   }
     }
}
//---------------------------------------------------------------------------
void TForm4::CalcoloIncrementi()
{
int i,j;
for(i=0 ; i<ord ; i++)
   {
   incr[i]=0;
   for(j=0 ; j<ord ; j++)   incr[i] += Jinv[i][j]*res[j];
   }
}
//---------------------------------------------------------------------------
//---Funzioni di supporto per il calcolo dello jacobiano--
//calcolo derivata dPdE
double TForm4::dPdE(int p,int q)
{
int j;
double J=0;
if (p==q)  {
        for(j=0 ; j<p ; j++)    J+=Y[p][j]*E[j][k]*cos(d[p][k]-d[j][k]-th[p][j]);
        for(j=p+1 ; j<n ; j++)  J+=Y[p][j]*E[j][k]*cos(d[p][k]-d[j][k]-th[p][j]);
             J+=2*Y[p][p]*E[p][k]*cos(th[p][p]);
           }
else  J=Y[p][q]*E[p][k]*cos(d[p][k]-d[q][k]-th[p][q]);
return J;
}

//calcolo derivata dPdd
double TForm4::dPdd(int p,int q)
{
int j;
double J=0;
if (p==q)  {
        for(j=0 ; j<p ; j++)  J+=Y[p][j]*E[j][k]*sin(d[p][k]-d[j][k]-th[p][j]);
        for(j=p+1 ; j<n ; j++)  J+=Y[p][j]*E[j][k]*sin(d[p][k]-d[j][k]-th[p][j]);
             J*=(-E[p][k]);
           }
else  J=Y[p][q]*E[p][k]*E[q][k]*sin(d[p][k]-d[q][k]-th[p][q]);
return J;
}

//calcolo derivata dQdE
double TForm4::dQdE(int p,int q)
{
int j;
double J=0;
if (p==q)  {
        for(j=0 ; j<p ; j++)  J+=Y[p][j]*E[j][k]*sin(d[p][k]-d[j][k]-th[p][j]);
        for(j=p+1 ; j<n ; j++)  J+=Y[p][j]*E[j][k]*sin(d[p][k]-d[j][k]-th[p][j]);
             J-=2*Y[p][p]*E[p][k]*sin(th[p][p]);
           }
else  J=Y[p][q]*E[p][k]*sin(d[p][k]-d[q][k]-th[p][q]);
return J;
}

//calcolo derivata dQdd
double TForm4::dQdd(int p,int q)
{
int j;
double J=0;
if (p==q)  {
        for(j=0 ; j<p ; j++)  J+=Y[p][j]*E[j][k]*cos(d[p][k]-d[j][k]-th[p][j]);
        for(j=p+1 ; j<n ; j++)  J+=Y[p][j]*E[j][k]*cos(d[p][k]-d[j][k]-th[p][j]);
             J*=E[p][k];
           }
else  J=-(Y[p][q]*E[p][k]*E[q][k]*cos(d[p][k]-d[q][k]-th[p][q]));
return J;
}
//---------------------------------------------------------------------------
//----------------------------------------------------------------------------
void __fastcall TForm4::FormShow(TObject *Sender)
{
//Newton-Raphson
int i,j;

/*inizializzazione profilo tensioni*/
 for(i=0 ; i<n ; i++)
    for(j=0 ; j<numit+1 ; j++)
       {
       E[i][j]=dataval[2][i];
       d[i][j]=dataval[3][i];
       }

//algoritmo Newton
for(k=0 ; k<numit ; k++)
   {
   CalcoloResiduo();   /*calcolo di res*/
   CalcoloJacobiano();  /*calcolo di J*/
   CalcoloInversa();   /*calcolo inversa dello jacobiano Jinv*/
   CalcoloIncrementi(); /*prodotto tra Jinv e res*/

   /*aggiornamento incognite*/
   for(i=0 ; i<nE ; i++)     E[Jinc[i]][k+1]=E[Jinc[i]][k]+incr[i];
   for(i=nE ; i<ord ; i++)   d[Jinc[i]][k+1]=d[Jinc[i]][k]+incr[i];
   }

   //Calcolo terminato;conversione delle fasi in gradi...
for(i=0 ; i<n ; i++)
   for(j=0 ; j<numit+1 ; j++)
       {
       d[i][j] *= 180/pi;
       }

//visualizzazione risultati sulla form 4...
TListItem * item;
ListView->Items->Clear();

for (j=0; j<numit+1; j++)
    {
    for (i=0; i<n; i++)
        {
        item = ListView->Items->Add();
        item->Caption = j;
        item->SubItems->Add(i+1);
        item->SubItems->Add(E[i][j]);
        item->SubItems->Add(d[i][j]);
        }
    ListView->Items->Add();
    ListView->Items->Add();
    ListView->Items->Add();
    }
}
//----------------------------------------------------------------------------



Newton.h -------------------------------------------------Torna Su

//---------------------------------------------------------------------------
#ifndef NewtonH
#define NewtonH
//---------------------------------------------------------------------------
#include "Globalvar.h"

#include <vcl\Classes.hpp>
#include <vcl\Controls.hpp>
#include <vcl\StdCtrls.hpp>
#include <vcl\Forms.hpp>
#include <vcl\ComCtrls.hpp>
//---------------------------------------------------------------------------
class TForm4 : public TForm
{
__published: // IDE-managed Components

    TListView *ListView;
    void __fastcall FormShow(TObject *Sender);
private: // User declarations

//funzioni
void CalcoloResiduo();
void CalcoloJacobiano();
void CalcoloInversa();
void CalcoloIncrementi();
double dPdE(int,int),dPdd(int,int);
double dQdE(int,int),dQdd(int,int);

public// User declarations
 __fastcall TForm4(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern TForm4 *Form4;
//---------------------------------------------------------------------------
#endif


***** Unit Globalvar ******************************

Globalvar.cpp -------------------------------------------Torna Su

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop
#include "Globalvar.h"

/*variabili globali*/
int n;    //numero nodi
int nP,nE,ord;   //numero eq in P;numero incognite E  ;ordine jacobiano

double Y[maxnodi][maxnodi],th[maxnodi][maxnodi]; //moduli e fasi ammettenze
double dataval[4][maxnodi];  //vettori modulo e fase tensioni nodali iniziali
                                                 //e potenze nodali in ingresso
int tiponodo[maxnodi];   //array di tipo nodo
int Jeq[2*maxnodi],Jinc[2*maxnodi]; //Arrays di supporto calcolo Jacobiano

/*Funzioni globali*/
void Segnalazione(int);
double mod(cplx);
double arg(cplx);

//---------------------------------------------------------------------------
// Funzione segnalazione errori: fornisce una stringa diversa nel messagebox a seconda dell'intero in ingresso
void Segnalazione (int e)
{
String strsegn[5];
// definizione stringhe segnalazione
strsegn[0]="Rivedi matrice ammettenze:\n\
rilevati elementi non vuoti fuori\n\
dalle dimensioni acquisite.\n";

strsegn[1]="Rivedi colonne dati :\n\
rilevati elementi non vuoti fuori\n\
dalle dimensioni acquisite.\n";

strsegn[2]="E' necessario riacquisire i dati:\n\
rilevati tipi di nodo non previsti.\n";

strsegn[3]="Numero di equazioni\n\
e numero di incognite\n\
non coincidono.\n";

    // creazione finestra segnalazione
Application->MessageBox(strsegn[e].c_str(),"Attenzione:",MB_ICONEXCLAMATION);
}
//---------------------------------------------------------------------------
 /* Modulo di un complesso*/
double mod(cplx C)
 {
  return (sqrt(C.Re*C.Re+C.Im*C.Im));
 }
//---------------------------------------------------------------------------
/*Argomento di un complesso*/
double arg(cplx C)
{
if (C.Re>0) return(atan2(C.Im,C.Re));
if (C.Re<0) return (atan2(C.Im,C.Re)+pi);
if (C.Im>0) return(pi/2);
if (C.Im<0) return(3*pi/2);
return(0);
}
//----------------------------------------------------------------------------



Globalvar.h ---------------------------------------------Torna Su

//---------------------------------------------------------------------------
#ifndef GlobalvarH
#define GlobalvarH
//---------------------------------------------------------------------------
#define Ed 0
#define PQ 1
#define PE 2
#define Pd 3
#define QE 4
#define Qd 5
#define pi 3.1415926535897932384626433832795
#define maxnodi 7  //numero massimo di nodi gestiti dal programma
#define numit 20   //numero di iterazioni eseguite dagli algoritmi

#include <math.h>
//---------------------------------------------------------------------------

/*tipi di dato*/
typedef struct  { double Re;
                     double Im;
                          } cplx;

/*variabili globali*/
extern int n;      //numero nodi
extern int nP,nE,ord;      //numero eq in P;numero incognite E;ordine jacobiano
extern double Y[maxnodi][maxnodi],th[maxnodi][maxnodi]; //moduli e fasi ammettenze
extern double dataval[4][maxnodi]; //vettori modulo e fase tensioni nodali iniziali
                                                              //e potenze nodali in ingresso
extern int tiponodo[maxnodi];   //array di tipo nodo
extern int Jeq[2*maxnodi],Jinc[2*maxnodi];    //Arrays di supporto calcolo Jacobiano

/*funzioni*/
void Segnalazione(int);
double mod(cplx);
double arg(cplx);
//-----------------------------------------------------------------------------
#endif



Torna all' indice      Torna  Su