Ingegneria Forum
Ingegneria Edile, Strutturale & Geotecnica => .:C#, Excel, VB e Programmazione:. => Topic started by: marchionili on 10 December , 2011, 22:45:53 PM
-
Sto studiando il software di zax2010 perché ho intenzione di:
1) Creare un'interfaccia grafica con il relativo codice sorgente su Visual C#
2) Aggiungere la precompressione all'analisi tensionale
Il risultato, se Gilean approverà, sarà messo nella sezione download.
Purtroppo non sono nè un esperto di C# e di C++ e nè un ingegnere del vostro livello ma cerco di fare del mio meglio. Procedo a piccoli passi leggendo il post sul forum ed il codice rilasciato. Qui di seguito vi espongo alcune domande che sorgono spontanee analizzando il codice. Oggi ho dato un'occhiata al file .h con le variabili. Quando avrò compreso tutto il codice scritto in C++ abbandonerò questa discussione e procederò nell'altra. Tutto ciò perché ho timore di fare domande troppo ovvie, magari già affrontate nel seguito della precedente discussione e con il rischio di allungare troppo il post originale.
DOMANDE
01.Perché non usare le variabili più precise double oppure meglio ancora decimal?
02.Perché si assume un valore positivo di sforzo normale quando è di compressione?
03.Dal punto di vista informatico che significato hanno questo gruppo di stringhe: (mi serve una rapida definizione scritta con parole vostre che mi illustri il significato di * e delle parentesi... il significato di void... perché calcola_caratt_geometriche (struct poligono_sezione *) e non calcola_caratt_geometriche(struct poligono_sezione *)... ecc... giusto per capire sommariamente...)
struct geometria_sezione calcola_caratt_geometriche (struct poligono_sezione *);
void inversione_poligono (int);
struct deform verifica_SLE(struct soll_esterne);
struct lungh_fibra calcola_lungh_fibra(struct poligono_sezione,float);
struct deform_ultime_sezione calcola_deform_ultime(struct poligono_sezione *,float,int,float,float);
float parabola_rett(float,float);
float elast_plast_indef(float,float,float);
struct risultante_n risult_compr(struct poligono_sezione *,struct armature_sezione,float,float,float,struct deform_ultime_sezione);
struct risultante_n risult_traz(struct poligono_sezione *,struct armature_sezione,float,float,float,struct deform_ultime_sezione);
struct risultante_n_finale determina_asse_neutroSLU(struct poligono_sezione *,struct armature_sezione,float);
struct dominio_rottura calcola_dominio_SLU(float);
void definisci_baricentro(void);
struct coord_proiez convert3Dto2D(float,float,float,float,float,float,float);
struct n_limite definisce_nlimite(void);
?
ciao e grazie
-
Rispondo io. Il celeberrino.
Intanto ti prego. Controllati! Non farmi più complimenti. E' una richiesta ben precisa, 'che altrimenti non ti rispondo più.
Domanda 1: perchè no? Si può fare. Avere double dappertutto invece che 'semplici' float.
Domanda 2: E' una convenzione. Così come è stata una convenzione, agli SLE, dire che uno spostamento del baricentro , concorde con la compressione sia anch'esso positivo.
Ovviamente da tale convenzione discende tutto il resto.
Domanda 3: Quelle che riporti sono 'prototipi' delle funzioni.
In sintesi, informi il compilatore, prima che esso le debba compilare, di che natura sono le varie funzioni che incontrerà nel proseguo del listato.
Praticamente è come con le variabili. Per prima cosa le dichiari, poi le utilizzi.
In questo modo il compilatore si 'organizza' (non saprei dirti come ovviamente) lasciando i giusti spazi in memoria, ecc.
Nel C di Kernigan e Ritchie le funzioni avevano bisogno del prototipo prima solamente se non restituivano un valore int. Quando il comitato ANSI decise di standardizzare i vari dialetti C che prorompevano sulla scena, decise che era buona norma che tutte le funzioni fossero prima 'prototipate'.
Andiamo agli esempi. Parto dal semplice, andando verso il difficile
void inversione_poligono (int);
Protopito della funzione denominata inversione_poligono. Essa accetta in ingresso (parametri formali) una variabile di tipo int (mi pare fosse il numero del poligono da invertire) e restituisce il valore......NULLA (attenzione, non NULL, o 0) semplicemente questa è una funzione che non restituisce alcun valore, questo il significato di void che se lo cerchi come vocabolo inglese è letteralmente: indefinito.
float parabola_rett(float,float);
Prototipo della funzione denominata parabola_rett. Essa accetta in ingresso due variabili di tipo float, e restituisce alla fine un valore di tipo float.
struct deform verifica_SLE(struct soll_esterne);
Prototipo della funzione denominata verifica_SLE. Essa accetta in ingresso una variabile di tipo struct (una struct è una struttura dati che al suo interno contiene variabili di tipo più elementare, come float, int, ecc.) in particolare una variabile struct denominata soll_esterne.
La variabile struct soll_esterne deve essere dichiarata prima di protopizzare questa specifica funzione (perchè altrimenti il compilatore, non sapendo di che cosa è fatta la struttura dati soll_esterne, non può 'protopizzare' bene la funzione).
Altra cosa attenzionare bene è che soll_esterne non una vera e propria variabile. Essa a sua volta è il 'prototipo' della struttura dati. In sintesi, un nuovo tipo di dati, come float, int, double, per intenderci. Così come tu dichiari nel tuo listato una variabile:
int pippo;
così dichiarerai:
struct soll_esterne soll;
Ovvero hai creato la struttura dati soll, che ha le caratteristiche del prototipo struct soll_esterne.
Pare complicato, ed in parte lo è. Ma se guardi nel file .h e nel file .cpp troverai tanti esempi che ti consentiranno di capire meglio.
Infine la funzione in oggetto restituisce un valore che è di tipo struct deform (altra struttura dati che deve essere dichiarata prima del prototipo della funzione in oggetto). Anche in questo caso struct deform è il prototipo della struttura dati.
Piccolo inciso. In tutti i linguaggi strutturati alle funzioni possono essere passate un numero qualsiasi di variabili in ingresso, nessuno, 1, 2, 100. Invece in uscita le funzioni prevedono o void (nessuna uscita) o una ed una sola variabile.
Per cui se tu avessi una funzione a cui fornisci in ingresso i lati di un rettangolo, e volessi che in uscita ti desse sia l'area che il perimetro, non potresti farlo. O inserisci in ingresso della funzione un flag (voglio in uscita a*b, oppure voglio in uscita 2*(a+b)), e chiami la funzione due volte, oppure crei due funzioni differenti, specializzate, una per il calcolo dell'area, una per il calcolo del perimetro.
Se però il valore restituito dalla funzione è un 'puntatore', ovvero una posizione in memoria, all'uscita dalla funzione tu avrai la possibilità, sapendo come è strutturata la memoria nei 'dintorni' del puntatore, di avere più informazioni dell'unica variabile che ti viene fornita dalla funzione stessa.
Io con i puntatori non sono mai entrato troppo in confidenza.
Nel caso della restituzione di una variabile di tipo struct, in effetti ti viene restituito di fatto un puntatore (anche se non sembra), il puntatore alla posizione in memoria della struttura stessa. Se la struttura dati ha al suo interno 10 variabili elementari, io all'uscita dalla funzione, mi trovo tutti e 10 i valori che mi servono, in quanto 'incapsulati' all'interno della struttura restituita.
Infine andiamo al prototipo più complicato:
struct geometria_sezione calcola_caratt_geometriche (struct poligono_sezione *);
struct poligono_sezione * cos'è? Un puntatore.
Traducendo, si informa il compilatore che in ingresso non ci sarà una struttura dati di tipo struct poligono_sezione, ma un array (un vettore) di variabili di tipo struct poligono_sezione. Poichè il compilatore conosce la forma di tale struttura (ovvero quanto spazio occupa in memoria ogni variabile di tipo poligono_sezione) è anche in grado di 'saltare' da una variabile struct all'altra. Per cui in fase di chiamata della funzione troverai la riga:
geo=calcola_caratt_geometriche(poli);
Ma prima avevo dichiarato le variabili poli come:
struct poligono_sezione poli[5];
Ovvero un vettore di variabili poli[0], poli[1], ecc. e poli che vedi nella chiamata, cosè? Il puntatore del vettore.
Ovvero io passo alla funzione calcola_caratt_geometriche la locazione in memoria dove è contenuto il primo valore di poli[0].
D'altra parte per determinare le caratteristiche geometriche dell'intera sezione devo sapere tutto dei singoli poligoni che la costituiscono.
Ovviamente, ed è il bello della programmazione strutturata, avrei potuto agire anche in maniera differente. Piuttosto che far ingoiare ad una funzione tutti i poligoni, avrei potuto creare una funzione che agiva sul singolo poligono, restituendomi le caratteristiche geometriche dei singolo poligono, e quindi con una funzione più in 'alto' trattare i singoli risultati per arrivare a quelli della sezione nella sua totalità.
Penso che già così sia anche troppo.
-
C é davvero complicatissimo... :(
01.Ok, grazie mille.
02.Ma non é negativo lo sforzo di compressione e positivo quello di trazione?
03.Ok grazie mille, ho inteso. In pratica dato che una funzione in C++ ammette un solo output l'unico modo per far si che la funzioni sputi fuori più di una variabile e quella di raggruppare più variabili in un gruppo struct. Detto in altro modo é una richiesta specifica della grammatica del linguaggio di programmazione utilizzato.
:help:
Continuo a non capire il secondo pezzo del tuo messaggio (Infine andiamo al prototipo più complicato:... Penso che già così sia anche troppo.). Il valore * deve essere messo perché come argomento della sezione c'é almeno uno 'struct' che contiene un vettore oppure ha qualche significato in più e può essere omesso anche in queste circostanze?
Inoltre le due scritture in C++ sono identiche oppure no:
struct variabili funzione(struct variabili)
struct variabili funzione (struct variabili)
Ovvero lo spazio messo prima della parentesi é ininfluente oppure ha anche questo un significato?
Non vuoi che ti ringrazi ma sei davvero gentilissimo! Grazie grazie e ancora grazie!
p.s.:
float poli[5];
crea un vettore che ha 5 elementi mentre
poli = {2,3,4,5,8};
assegna un valore alle 5 variabili del vettore, giusto?
-
I grazie puoi continuare a darmeli senza problemi, sempre se ti va. E' il 'celeberrimo', 'grandissimo', ecc. che ti sono preclusi. :asd: :asd:
Le due scritture che riporti sono assolutamente identiche. Gli spazi vengono letteralmete 'mangiati' dal compilatore e non significano nulla.
Andiamo al simbolo *
Con questo si indica solamente che il parametro formale in ingresso non è una variabile 'normale' (un int, un float, una struct), bensì il puntatore ad una variabile di tipo int, float o struct
(puntatore=locazione di memoria)
Se avessi un vettore: float vett[10], vettore costituito da 10 elementi di tipo float (da 0 a 9) e volessi passarli tutti in un colpo solo ad una funzione che potrà farne ciò che vuole, scriverei il prototipo della funzione:
void funzione_vettore(float *);
(ovvero la funzione accetta in ingresso un puntatore ad una variabile di tipo float)
e poi nel corpo del mio listato, avrei una chiamata così:
funzione_vettore(vett);
(dove vett senza alcun indice è proprio la locazione di memoria, il puntatore dunque, dove risiede il primo elemento del vettore vett[10]).
Infine ti chiedo scusa per il "Penso che già così sia anche troppo". Il problema è che questi sono dettagli 'ostici' ed a mettere troppa carne al fuoco si rischia di capirci poco. Andare un passo alla volta è sempre opportuno.
-
p.s.:
float poli[5];
crea un vettore che ha 5 elementi mentre
poli = {2,3,4,5,8};
assegna un valore alle 5 variabili del vettore, giusto?
Mi pare giusto.
Comunque io ho sempre fatto le due cose insieme, ovvero dichiarazione ed assegnazione contemporanea: float poli[5]={2,3,4,5,8};
e funziona.
Penso che dovrebbe funzionare anche come lo hai scritto tu.
-
Rispondo io. Il celeberrino.
Intanto ti prego. Controllati! Non farmi più complimenti. E' una richiesta ben precisa, 'che altrimenti non ti rispondo più.
ihihihih
io lo avrei mandato a quel paese gia da subito.
Celeberrimo ahahahahah
-
ihihihih
io lo avrei mandato a quel paese gia da subito.
Celeberrimo ahahahahah
In realtà ho fatto un errore.
Il Celeberrimo, nel titolo del post, è riferito al software, non al sottoscritto......
Ah! Montarsi la testa!
-
ma perche' celeberrimo non e' un complimento?
-
Sto studiando il software di zax2010 perché ho intenzione di:
1) Creare un'interfaccia grafica con il relativo codice sorgente su Visual C#
2) Aggiungere la precompressione all'analisi tensionale
Mi permetto di darti qualche consiglio: non puntare troppo lontano come obiettivo iniziale, altrimenti rischi di perdere l'entusiamo strada facendo (a me è successo con l'implementazione delle OpenGL nei miei software)
Dalle domande che hai posto mi sembra che tu sia partito con il compilatore aperto, meglio se in un primo step guardi dei libri/testi (io sono partito con due libri (anche abbastanza economici): "Programmare con il .net framework" vol. 1 e 2(mondadori informatica). Li pagai circa 15 euro l'uno ma sono veramente chiari).
Te lo dico per esperienza: se ti dai dei piccoli obiettivi, una volta raggiunti sei motivato a migliorare quanto raggiunto, quindi cominci a riguardare il codice, lo migliori, capisci meglio alcuni aspetti, inevitabilmente butti quasi tutto perchè si può fare meglio e ricominci...
Alessandro
-
Se avessi un vettore: float vett[10], vettore costituito da 10 elementi di tipo float (da 0 a 9) e volessi passarli tutti in un colpo solo ad una funzione che potrà farne ciò che vuole, scriverei il prototipo della funzione:
void funzione_vettore(float *);
(ovvero la funzione accetta in ingresso un puntatore ad una variabile di tipo float)
e poi nel corpo del mio listato, avrei una chiamata così:
funzione_vettore(vett);
(dove vett senza alcun indice è proprio la locazione di memoria, il puntatore dunque, dove risiede il primo elemento del vettore vett[10]).
Se invece si scrivere:
void funzione_vettore(float);
nel corpo del listato si deve scrivere ad esempio:
funzione_vettore(vett[3]);
era questo collegamento che non avevo fatto. Non é certo facile ma non é neppure tanto complicato e la questione più nodosa e faticosa é entrare nell'ottica. Sei molto bravo ad esprimerti, sai essere precisissimo e semplice allo stesso tempo, meglio di un manuale! :clap:
Grazie mille
-
Mi permetto di darti qualche consiglio: non puntare troppo lontano come obiettivo iniziale, altrimenti rischi di perdere l'entusiamo strada facendo (a me è successo con l'implementazione delle OpenGL nei miei software)
Dalle domande che hai posto mi sembra che tu sia partito con il compilatore aperto, meglio se in un primo step guardi dei libri/testi (io sono partito con due libri (anche abbastanza economici): "Programmare con il .net framework" vol. 1 e 2(mondadori informatica). Li pagai circa 15 euro l'uno ma sono veramente chiari).
Te lo dico per esperienza: se ti dai dei piccoli obiettivi, una volta raggiunti sei motivato a migliorare quanto raggiunto, quindi cominci a riguardare il codice, lo migliori, capisci meglio alcuni aspetti, inevitabilmente butti quasi tutto perchè si può fare meglio e ricominci...
Alessandro
Questo é vero ma tolto qualche parolina come struct e * il resto mi sembra abbastanza accessibile e molto simile a C# che ho approfondito dai corsi di Gilean. Spero di riuscire ad arrivare alla fine di questo compito, se ciò avverrà sarà grazie alla vostra pazienza. Sto facendo di tutto (é da un mese che vado a dormire alle 00:20) per poter riuscire nell'intento e poter contribuire alla comunità. Un forum, una comunità che lavora su un unico codice! Pensa che bello e pensa a che risultati si potrebbe arrivare! Semplicemente fantastico. Ho ragazzi non so più cosa dirvi... io ce la metto tutta se poi mi dovessi sbagliare vi chiedo scusa... avrò perso del tempo, pazienza... I libri sono una cosa importante ma credo che li leggerò solo dopo che avrò completato qualche programmino per approfondire ulteriormente il linguaggio. Ho iniziato con i video di Gilean (tutta teoria) ed ora vorrei fare pratica con il codice di zax2010. In futuro cercherò sicuramente qualche buon libro ma passare mesi e mesi a leggere manuali in questo momento sarebbe sbagliato. Inoltre leggere un linguaggio su cui si ha già un'infarinatura é un'altra cosa. Mi posso sbagliare ma credo che procedere a piccoli passi non sia una cosa sbagliata. Vi prego datemi un incoraggiamento!
-
Ciao
Mi chiedevo come vuoi gestirre l'interfaccia. Immagino tu utilizzi WPF e non windows form. Seppure vedo che sei un po' allergico ai manuali ti consiglio oltre al libro sopra citato di John Charp anche "Pro WPF in C# ..." (io ho la versione 2008 che si riferisce al .NET 3.5).
Sono anche io alle prime armi con C#.
Per ora ho creato una interfaccia di input in WPF che a mio avviso sempre deve:
- permettere di passare da una textbox all'altra tramite il tasto invio. Magari evidenziare la cella col focus.
- quando si lancia una elaborazione tutti gli input devono essere salvati in un file esterno (io salvo o in un database o in un file testo)
- quando si riapre il programma gli ultimi input inserirti devono essere i valori di default, cioè è necessario ricaricare da file esterno i valori precedentemetne salvati.
- definire il menu tipo (Apri - salva - salva con nome...)
Ora personalemnte sto litigando con la "flexgrid"...
Ogni tanto penso che più diretto del basic di openoffice ci sia poco: interfaccia già pronta, basic semplice ma abbastanza completo... il tutto gratuito :)
Nel caso qualcosa che ho fatto ti possa essere utile batti un colpo! :piacere:
ciao
MArco
-
se posso consigliare, le WPF richiedono qualche conoscenza di xml. Fossi in voi partirei dalle care vecchie windows form.
-
Ciao
Mi chiedevo come vuoi gestirre l'interfaccia. Immagino tu utilizzi WPF e non windows form. Seppure vedo che sei un po' allergico ai manuali ti consiglio oltre al libro sopra citato di John Charp anche "Pro WPF in C# ..." (io ho la versione 2008 che si riferisce al .NET 3.5).
Sono anche io alle prime armi con C#.
Per ora ho creato una interfaccia di input in WPF che a mio avviso sempre deve:
- permettere di passare da una textbox all'altra tramite il tasto invio. Magari evidenziare la cella col focus.
- quando si lancia una elaborazione tutti gli input devono essere salvati in un file esterno (io salvo o in un database o in un file testo)
- quando si riapre il programma gli ultimi input inserirti devono essere i valori di default, cioè è necessario ricaricare da file esterno i valori precedentemetne salvati.
- definire il menu tipo (Apri - salva - salva con nome...)
Ora personalemnte sto litigando con la "flexgrid"...
Ogni tanto penso che più diretto del basic di openoffice ci sia poco: interfaccia già pronta, basic semplice ma abbastanza completo... il tutto gratuito :)
Nel caso qualcosa che ho fatto ti possa essere utile batti un colpo! :piacere:
ciao
MArco
Si si, sono molto interessato! Cavolo ma tu fai le cose in grande! :) Se riesci a spiegarmi come fare sarei felicissimo. Seguendo i corsi di Gilean ho imparata ad usare la windows form. Ho aperto proprio ora la WPF e noto che é davvero molto più carina. Ci sono anche altri vantaggi nell'usare questo tipo di interfaccia? La questione del database credo sia essenziale per i parametri dei materiali (gammac, fdb, fyk, ecc...). Tutte le info che riesci a darmi mi saranno di aiuto. Ora però prima di procedere devo analizzare nel dettaglio il codice di zax2010 e penso che ci metterò parecchio.
Nel frattempo se avessi voglia di fare una videopresentazione per i punti sopra faresti davvero una gran cosa. :coffee:
-
se posso consigliare, le WPF richiedono qualche conoscenza di xml. Fossi in voi partirei dalle care vecchie windows form.
Quali sono i vantaggi nell'usare le WPF e i fogli xml? Tra il resto é complicato creare un tasto che stampa su pdf o su una classica stampante i dati di output?
grazie e a presto
P.S.: l'xml sembra identico all'xhtml... per caso si possono anche inserire dei fogli di stile in css su visual studio? se si potesse saprei fare delle cose megagalattiche... :)
-
Aggiungo: esistono dei file xml già pronti e solo da ritoccare opportunamente come avviene per i template sul web?
esempio: http://www.freewebsitetemplates.com/ (http://www.freewebsitetemplates.com/)
http://www.freewebsitetemplates.com/download/bikersclubtemplate (http://www.freewebsitetemplates.com/download/bikersclubtemplate)
ciao e grazie
-
up! up! up!
-
che io sappia no.
-
Questa sera ho incominciato a leggere il secondo file ma già alla prima riga mi sono dovuto fermare. Ho trovato le seguenti righe di codice:
#include "ver_SLU_SLE.h"
#include "math.h"
Se "#include" serve per includere un altro file nel codice allora deduco che nella mia cartella decompressa dovrei trovare il file math.h ma io non lo vedo, perché?
P.S.:Quali sono i vantaggi nell'usare le WPF e i fogli xml oltre ad una personalizzazione grafica più evoluta?
Grazie
-
gli include ti permettono di includere librerie di funzioni o intere classi. Il fatto che tu non le veda nel tuo progetto non significa che debbano per forza esserci. Ti ricordo che tu stai scrivendo un programma appoggiandoti alle Framework.net, che non sono altro che librerie di classi. Di conseguenza con una chiamata simile, stai includendo una libreria che si trova all'interno delle framework.
sul p.s. personalmente non ho mai usato le wpf, mi trovo bene con windows form, quindi non saprei dirti.
-
Gilean dice bene.
Ma precisiamo meglio.
Hai intuito bene pensando che il comando #include (una direttiva del pre-processore) serva ad 'infilare' il contenuto di ver_SLU_SLE.h all'interno di un altro listato.
Che tu non trovi tutti i file che ti aspetti è dovuto al fatto che alcuni include file fanno parte della dotazione standard di ogni compilatore c.
Se guardi bene nella directory di installazione del tuo compilatore troverai due directory, la prima include, la seconda lib. Poi se guardi dentro la prima, troverai proprio il math.h che pare mancarti, ed infine nella seconda troverai infine un file math.lib.
Quest'ultimo è forse per te un concetto nuovo. Si tratta di un file al cui interno sono contenuti non i sorgenti, ma un pre-compilato di una serie di funzioni.
Il compilatore (o meglio il linker) è in grado di estrarre dal file .lib la funzione che gli serve, senza dover ogni volta compilare un eventuale listato 'esplicito'.
Ad esempio il file da include math.h in questione è necessario perchè tra le varie righe si va a chiamare una funzione sqrt() (estrazione della radice quadrata), che appunto è una funzione di libreria contenuta nel file math.lib
Piccola digressione. Il successo del C (e dei suoi successivi derivati) è dovuto in parte al piccolo numero di 'parole chiave' che costituiscono il linguaggio in se (20-25 non di più), che ne rendono agevole l'apprendimento.
Ma la vera idea geniale (per quei tempi, ovviamente - stiamo parlando della metà degli anni '70, ovvero 35 anni fa, che in informatica sono ere geologiche), fu quella di 'staccare' la parte 'logica' del linguaggio dalla parte input/output più legata ai sistemi operativi. In questo modo il linguaggio rimane sostanzialmente sempre lo stesso, in qualsiasi sistema operativo esso venga implementato. Sono le funzioni di libreria standard, che tu programmatore 'finale' ti trovi belle e pronte, che eventualmente vengono specializzate in funzione del sistema operativo, della macchina, ecc.
Ad esempio, all'interno di math.lib trovi la funzione fabs(), che restituisce il valore assoluto di un numero float.
Ora, io immagino che una tale funzione operi a livello di bit. Ovvero dato un numero non fa altro che azzerare il bit che indica il segno del numero. Immagino sempre (perchè in effetti non lo so bene) che ci possano essere sistemi in cui il segno meno venga definito da un bit settato a 0, oppure ad 1, e sistemi in cui il bit del segno è il primo bit del numero, oppure l'ultimo.
Ecco in questo caso, il mio programma chiama la funzione fabs(), e non mi importa nulla di come la funzione funziona al suo interno (è quella che gli americani chiamano black-box), sarà il programmatore che ha 'personalizzato' la funzione per un dato sistema a conoscere i dettagli dell'implementazione. Ed il mio listato potrà essere implementato in una macchina unix o dos o cos'altro vuoi senza modifiche.
-
Grazie di tutto. Ho provato a creare un nuovo progetto in C++ per vedere questo file math.h ma ottengo questo errore:
Libreria non registrata. (Eccezione da HRESULT: 0x8002801D (TYPE_E_LIBNOTREGISTERED))."
Sarà un problema del mio programma? Sto usando la versione 2010 ultimate... mah... molto strano... C# parte e funziona ma C++ no... :byebye:
Sto leggendo il codice e sono alla prima funzione (spero nelle vacanze di andare un po' più in fretta...) ovvero quella che calcola le caratteristiche della funzione e comincio ad addentrarmi nella parte di calcolo e meno informatica e questo in parte mi rallegra ma ho delle piccole domandine che non capisco.
1) Perché dopo l'asterisco c'é la variabile polic e non si trova:
struct poligono_sezione * polic
dentro la funzione calcola_caratt_geometriche?
2) Si azzerano tutte le variabili geo perché altrimenti C++ da a loro un valore casuale come C#?
3) Perché nel ciclo for polic[np].numv é usato senza essere prima definito? perché l'assegnazione é fatta in una funzione che gira dopo [ struct deform verifica_SLE(struct soll_esterne soll) ]?
4) Perché si moltiplicano i mattoncini delle aree per il coefficiente di omogeneizzazione? :mmm:
grazie e buone feste a tutti!
P.S.: X zax2010 e Gilen: Sul mio skype ho aggiunto un certo zax2010, il mio nome skype e marchionili, aggiungetemi per favore così qualche sera ci si conosce!
-
Un plauso alla tua caparbietà.
E' per questo che continuerò a risponderti, anche se il suggerimento di Alex_Drake di munirti di un buon manuale, sia meglio di brancolare nel buoi come fai tu.
Facciamo un esempio.
Per prima cosa guarda questo prototipo di funzione:
float perimetro (float,float);
Tradotto in parole significa che questa funzione accetta in ingresso due numeri in virgola mobile, e restituisce un numero in virgola mobile. Il fatto che si chiami perimetro ti fa intuire cosa essa debba calcolare. Infatti, andiamo al corpo della funzione vera e propria:
float perimetro (float lato1,float lato2)
{
float perim;
perim=2*(lato1+lato2);
return (perim);
}
Nulla di complicato mi pare. Se poi dici che con la parte più 'aritmetica' del linguaggio te la cavi qui la cosa è semplicissima.
Vediamo però un pezzettino di codice in cui tu utilizzerai la funzione appena creata:
.
.
.
a=10.0; b=20.0;
c=perimetro(a,b);
.
.
.
Ho inizializzato le variabili a e b, tanto per fare, esse deriveranno da quello che vuoi tu, un input esplicito da parte dell'utilizzatore del programma, da formule e calcoli più sofisticati, ecc.
Ciò che dovresti notare è come le variabili del 'corpo' della funzione e le variabili della 'chiamata' alla funzione abbiano nomi differenti (lato1 e lato2 nel primo caso, e a e b nel secondo).
L'ho fatto apposta, perchè in effetti quando chiami la tua funzione, i valori numerici contenuti in a e b vengono copiati rispettivamente nei valori numerici delle variabili lato1 e lato2 che di fatto risultano 'dichiarate' proprio nella 'dichiarazione' della funzione. Ecco perchè tu non hai più bisogno di dichiarare tali variabili all'interno della funzione stessa, ed ecco perchè la funzione può utilizzare le variabili lato1 e lato2 al suo interno come meglio gli aggrada.
Altro fatto di notevole importanza è che lo 'sdoppiamento' delle variabili ti consentirebbe, ad esempio, all'interno della funzione perimetro di modificare i valori di lato1 e lato2 come meglio ti aggrada (nell'esempio che ti ho fatto questo non accade), senza che questo interferisca con i valori effettivi delle variabili a e b.
Ad esempio se a e b derivano da input dell'utente, chi ti dice che per sbaglio uno dei due non sia negativo? E' ovvio che in quel caso il calcolo del perimetro non sarà corretto. Ma se tu riscrivessi la funzione perimetro così:
float perimetro (float lato1,float lato2)
{
float perim;
lato1=fabs(lato1);
lato2=fabs(lato2);
perim=2*(lato1+lato2);
return (perim);
}
Ecco che il calcolo sarebbe corretto, perchè forzeresti lato1 e lato2 ad essere per forza positivi (ok, ho fatto un pò di brodo inutile, ma è un esempio e dovrebbe servire a farti capire). Ma le variabili a e b inserite dall'utente nel frattempo sono rimaste del segno che il malcapitato utente gli ha assegnato.
La tua seconda domanda contiene già la risposta. Si azzerano perchè altrimenti avrebbero valore casuale (secondo lo standard ANSI C questo comportamento è indefinito e dipende dalla implementazione del particolare compilatore. Esistono compilatori che dichiarando una variabile automaticamente la azzerano, altri che invece non lo fanno. Il buon programmatore o compila sempre con un compilare ben preciso, oppure si mette il ferro dietro la porta azzerando sempre prima le variabili, specie se come nella funzione che segnali, al valore finale delle singole variabili si arriva per sommatorie successive).
La domanda 3 mi pare un ripetizione della domanda 1.
Infine non sono su Skype come zax2010, per cui non saprei chi tu abbia trovato.
Domani mi cerco. Voglio vedere chi sono!
-
Grazie zax, ora capisco tutto. Dato che polic é un puntatore della variabile struct poligono_sezione e quest'ultima é già stata definita nel file .h allora numv é definito ed il fatto che non venga settata come area é dovuto al fatto che numv é una variabile di input assegnata dall'utente volta per volta. Cio mi fa pensare che oltre alle coordinate bisogni dire al programma quanti numeri di vertici si sono decisi di definire ma questo lo vedro/capirò più avanti. Una cosa che però proprio non riesco a comprendere é per quale ragione moltiplichi il mattoncino delle aree per il coefficiente di omogeneizzazione... :( Semai bisognerebbe moltiplicare le aree delle armature per il coefficiente di omegeneizzazione che se non ricordo male dovrebbe valere 15... :( Non é che omog vale 1 ed inizialmente il prog era stato pensato per risolvere sezioni miste acciao e calcestruzzo? ...
:byebye:
-
Nel topic sulle sezioni generiche e relative verifiche a presso-flessione, avevo spiegato il motivo dell'introduzione di 'omog'.
Capisco che il topic è lungo e leggerlo tutto è una fatica.
A parte le sezioni miste acciaio-calcestruzzo, esisterebbero le sezioni miste calcestruzzo-calcestruzzo, con calcestruzzi di resistenza differente. Nel topic avevo anche parlato di vuoti all'interno della sezione, ovvero altri contorni a cui semplicemente assegnare una variabile 'omog' pari a -1.
Insomma i casi possono essere molteplici.
Riguardo numv, certamente. Essa è un input 'esplicito' dell'utente (come in VCASLU dove inizialmente dici che il poligono costituente la sezione ha xx vertici, e ti 'spunta' una tabella di inserimento coordinate di vertici proprio di xx righe), oppure in qualche modo 'trovato' dal programma (perchè in una tabella da 100 righe riempi solamente le prime 10, oppure perchè hai disegnato un poligono ed i vertici sono....quelli che sono).
-
Ok, grazie mille. Sempre chiaro come sempre. Ho letto la prima parte del tuo primo tread e ti faccio i complimenti per l'algoritmo: davvero geniale! :inchino: L'unica formula che non sono riuscito a dimostrare é quella usata per il calcolo del momento centripeto. A me risulta 2*(d^2)/9 invece di (d^2)/4... :help:
Ixy = a*y*(a/2+x)*y/2+a*d/2*(x+2/3*a)*(y+1/3*d) ... da qui si arriva alla tua formula ma con la parte 2*(d^2)/9 al posto della tua... ??? Ho pure confrontato il tuo algoritmo con quello di un altro programma e confermo la correttezza della tua formulazione... ma dove cavolo sbaglio!!! :leggo:
-
Il momento centrifugo di un rettangolo, quando questo ha i lati paralleli agli assi coordinati è:
Jxy-rett=xg*yg*Area
(la formula generica sarebbe: Jxy=Jxgyg+xg*yg*Area - dove Jx0y0 sarebbe il momento centrifugo di una qualsiasi figura rispetto ad assi baricentrici, ma poichè nel caso specifico gli assi coordinati sono anche assi principali del rettangolo Jxgyg=0).
Invece per un triangolo con base parallela agli assi coordinati il momento centrifugo rispetto al baricentro vale: -a^2*d^2/72 (trovato in una dispensa on-line, in teoria si dovrebbe fare l'integrale doppio).
Pertanto il momento centrifugo del triangolo sarebbe: Jxy-triang=Jxgyg+xg*yg*area.
A questo punto sommando i due termini, componendo, sostituendo, ecc. si dovrebbe arrivare alla formula di cui al topic.
Dimmi intanto se anche tu stai procedendo allo stesso modo (ho utilizzato la stessa simbologia a-d del topic).
Io ho perso 2 ore oggi a far di conto, ma c'è qualcosa che non mi torna. Qualche segno sbagliato, qualche semplificazione di troppo ecc. Vedremo.
-
Risolto l'arcano.
Il momento centrifugo del triangolo rispetto agli assi baricentrici paralleli alla sua base non è come dicevo prima -a^2*d^2/72!!
Semplicemente non ha il segno negativo.
Infatti se segui tutto lo sviluppo che allego, si arriva alla formula voluta.
Ovviamente mi dirai se c'è qualcosa che non ti convince.
(http://s14.postimage.org/vxryrp3nx/doc00162220111227211748_001.jpg) (http://postimage.org/image/vxryrp3nx/)
P.S.: Qualsiasi Zax tu abbia trovato su Skype non sono io.
-
Supremo, grandioso, indiscutibile, indistruttibile e memorabile. :clap: Grazie zax! :clap: Ora mi é tutto più chiaro! Jxy assume sia il segno positivo che negativo a seconda dei casi. Quando P2 ha un'ordinata superiore rispetto a P1 il problema non si pone mentre quando si verifica l'opposto il triangolo che si considera nella formula e che concorre al calcolo di Jxy(P1-P2) é quello che non compone la figura sottesa dal lato P1-P2. Siccome la casistica impone il cambiamento del segno di Jxy la definizione della sommatoria dei pezzetti che compongono la figura é corretta. Detto in breve Jxy ha sia segno positivo che negativo, dipende dal caso che consideri.
Ciao e grazie ancora
:clap: :clap: :clap:
-
Conviene aggiungere qualche cifra:
/* Inclinazione degli assi principali d'inerzia rispetto agli assi X,Y di riferimento */
if (geo.ix-geo.iy!=0) geo.alfa=atan(-2*geo.ixy/(geo.ix-geo.iy))/2;
else { if (geo.ixy>0.0) geo.alfa=-0,785398163397448; else geo.alfa=0,785398163397448; }
if (geo.ix<geo.iy) geo.alfa+=1,5707963267949;
Meglio sarebbe scrivere il valore proposto da math.h però non so se esiste e come si scrive... su excel basta scrivere =pi.greco()/2.
-
zax, il programma che hai fatto lo hai anche testato dopo averlo scritto? avevi trovato delle anomaline o malfunzionamenti?
ciao e grazie come sempre
-
Si, Marchionili, certo.
Mi mettevo a dare listati che fossero bacati?
Ho fatto diverse prove con il VCASLU di Gelfi, per sezioni più o meno semplici. Ho riscontrato a volte valori corrispondenti alla virgola, altre volte differenze di poco conto.
Poi non saprei se per particolari condizioni qualcosa comunque non funziona. Ma ho riportato apposta tutti gli sviluppi teorici proprio per confrontarmi e per sentirmi dire se ciò che dicevo era corretto oppure no.
Sembrerebbe.....
-
La mia non era sfiducia ma curiosità. Hai anche provato a confrontarlo con il solutore di qualche software house oltre che quello di Gelfi?
sempre grazie
P.S.: Sto leggendo parallelamente il tuo tread principale e non ho capito la questione NMAXPOLI. Hai scelto un numero massimo di poligoli perché volevi evitare che l'utente abusasse delle potenzialità del software mandando in palla il proprio pc più vecchiotto oppure perché pensi realmente che più di 600 punti possano mandare in crisi anche i pc più performanti oppure perché non sapevi come far scegliere al programma il calcolo automatico di questo valore di input oppure qualche altro motivo a me sconosciuto?
-
Scusate l'intromissione ma la cosa mi incuriosisce ma non sò dove andare a trovare il listato.
Ho cercato nella sezione dowload del sito ma non ho trovato niente.
Qualcuno sarebbe così cortese da indicarmi dove poter cercare?
Grazie!
-
http://ingegneriaforum.it/index.php?topic=1870.90 (http://ingegneriaforum.it/index.php?topic=1870.90)
Nel primo post della pagina 7, trovi in allegato il listato.
-
Grazie mille, inizio a studiarmi un po' il programma!
-
Bravo! Ottima idea! :) Basta software di Gelfi e basta software house... usiamo e creiamo programmi open source... a codice aperto... gli informatici sono anni che si stanno dilettando (linux é un esempio...) perché non provarci anche noi? in fondo siamo ingegneri come loro no? benvenuto santacruz e grazie di esserti iscritto!