[C++ to Fortran] Conversione o riscrittura piccolissimo programma

[Warlord]

Premetto che so praticamente nulla di programmazione purtroppo..
sta di fatto che per la Tesi mi sia stato chiesto , all'ultimo , di scrivere poche righe di codice per confrontare i sisultati che si ottengono con 3 diverse funzioni ( formule ricavate sperimentalmente che dovrebbero descrivere lo stesso fenomeno fisico , nel mio caso conduttivita' di un nanofluido )

Considerando che non so nulla di programmazione, avevo gia' scritto la mia tesi, sono rimasto spiazzato dal dover imparare un linguaggio come il fortran ( specificatamente mi era stato chiesto di usare compaq visual fortran ) per implementare qualche riga di codiche ( 3 formule in croce ) entro martedi' ..

preso da buona voonta' cmq ( e nn potendo dire di no! ) mi sono fatto aiutare da 1 amico a scrivere in velocita'il programma in c++ ( unico linguaggio di cui qualcosina ricordavo anche se davvero poco ) pensando riuscire poi a trasformare il tutto in fortran e scoprendo che il contrario e' fattibile mentre nn riesco a fare C++ to Fortran !!

Chiedo umilmente se potete darmi qualche consiglio per riscrivere il programma ( che poi dovrei implementare anche meglio .. e' stato un lavoro fatto in fretta ) o come trasformarlo..

provo a postarlo ( sono poche righe ) sperando in qualche aiuto all'ultimo momento ( martedi' e' vicinissimo , menneno il tempo di contattare qualcuno )

--------------------------------------------------------------

#include<iostream>
#include<fstream>
#include<cmath>
using namespace std;

double bolz=1.381*(pow(10.0,-23));
double pi=3.14159;
double c=1;
double prh2o=5.8;
double preg=150;
double a=4*(pow(10.0,4));
double m=2.5;

double hamiltoncrosser(double kp,double kb,double n,double f){
double x=((kp+(((3/n)-1)*kb)-(((3/n)-1)*(kb-kp)*f))/(kp+(((3/n)-1)*kb)+((kb-kp)*f)));
return x;
}


double kumar(double t,double dp,double f,double db,double kb,double v){
double x=(((((2*bolz*t)/(pi*v*dp*dp)))*((f*db/2)/(kb*(1-f)*(dp/2))))*c)+1;
return x;
}

double reynolds(double kb,double t,double p,double dp,double v){
double x=(1/v)*sqrt((18*(kb*t))/(pi*p*dp));
return x;
}

double prasher(double kp,double kb,double f,double pr,double rey){
double x=((kp+(2*kb)+2*(kp-kb)*f)/(kp+(2*kb)-(kp-kb)*f))*(a*pow(rey,m)*pow(pr,0.333)*f);
return x;
}

int main() {
double ham;
double kum;
double pra;
double rey;
cout<<"Desideri usare acqua o glicoletilenico?"<<endl<<"1)Acqua"<<endl<<"2)EG"<<endl;
int x;
cin>>x;
cout<<"Calcolo il valore con Hamilton-Crosser"<<endl;
cout<<"Inserisci il valore della conduttivita' termica delle nanoparticelle"<<endl;
double kp;
cin>>kp;
cout<<"Inserisci la sfericita' delle nanoparticelle"<<endl;
double n;
cin>>n;
cout<<"Inserisci la frazione volumetrica delle nanoparticelle"<<endl;
double f;
cin>>f;
if(x==1){ham=hamiltoncrosser(kp,0.613,n,f);}
else {ham=hamiltoncrosser(kp,0.253,n,f);}
cout<<"Valore calcolato con la formula di Hamilton-Crosser:"<<ham<<endl;
cout<<"Calcolo il valore con Kumar"<<endl;
cout<<"Inserisci il valore della temperatura"<<endl;
double t;
cin>>t;
cout<<"Inserisci il valore del diametro medio nanoparticellare"<<endl;
double dp;
cin>>dp;
cout<<"Inserisci il valore della viscosita' dinamica del fluido"<<endl;
double v;
cin>>v;
if(x==1){kum=kumar(t,dp,f,0.00,0.613,v);}
else{kum=kumar(t,dp,f,0.00,0.253,v);}
cout<<"Valore calcolato con la formula di Kumar:"<<kum<<endl;
cout<<"Calcolo il valore con Prasher"<<endl;
cout<<"Inserisci il valore della densita' della nanoparticella"<<endl;
double p;
cin>>p;
if(x==1){
rey=reynolds(0.613,t,p,dp,v);
pra=prasher(kp,0.613,f,prh2o,rey);
}
else{
rey=reynolds(0.253,t,p,dp,v);
pra=prasher(kp,0.253,f,preg,rey);
}
cout<<"Valore calcolato con la formula di Prasher:"<<pra<<endl;
}
----------------------------------------------------------------

innanzitutto c'e' da dire che lo scopo e' trovare corrispondenza tra la mia x ( per chi mastica termotecnica e' la conduttivita' della sospensione normalizzata , cioe' quella della miscela / quella del fluido base ... ) e la mia variabile f

con questo programma per trovare un valore di x devo ogni volta inserire TUTTE le variabili .... vorrei poter specificare valore di tutte le variabili e che il programma stesso ricavasse tipo 1 tabella per la mia f che varia in un range ( chenneso' nel mio caso se 0.00 < f < 2 che trovasse x corrispondente per ogni valore del campo con passo prescelto , a multiplo di 0.05 ... cioe' per f= 0 per = 0.05 per = 0.10 po 0.15 e cosi' via penso abbia reso l'idea )
E' POSSIBILE fare 1 cosa simile ( sicuramente immagino possibile , ma diciamo possibile senza dover fare affidamento a qualche routine strana o qualsiasi cosa che io nn saprei nemmeno fare ) ???

l'output puo' essere salvato in formato txt o xls o qualsiasi cosa ?? ( mi ricordo che si poteva ma fortran non lo conosco ) o occorre qualche programma particolare per fare cio'??


mi scuso in anticipo per queste domande niubbissime e quasi offensive all'intelligenza umana , ma mi trovo alle strette e qualsiasi consiglio / aiuto in questo momento fa la differenza (momento in cui nn nn ho 1 manuale x fortran F90 sintetico , o tempo di leggere quei malloppi da 1000 e rotte pagine che ho trovato in rete ) ...

ps: c'e' qualcosa di piu' isi per sviluppare che sto compaq visual fortran che mi ha dato la facolta' ?! Immagino sia 1 ottimo ambiente di sviluppo ma gia' faccio fatica ad aprirlo...

grazie ancora in anticipo per qualsiasi consiglio !!!


la versione F90-F95 presumo possa fare di tutto di piu' ( leggendo qua e la' )

[a2000.1]

Program hwup
 Implicit Real*8(a-z)
 Parameter (bolz=1.381d-23, pi=3.14159, c=1d0, prh2o=5.8, preg=150, a=4d4, m=2.5)
 Integer*2 x

 print *,"Desideri usare acqua o glicoletilenico?"; print*, "1)Acqua"; print*,"2)EG"
 read*, x
 print *, "Calcolo il valore con Hamilton-Crosser"
 print*, "Inserisci il valore della conduttivita' termica delle nanoparticelle"
 read*, kp
 print*, "Inserisci la sfericita' delle nanoparticelle"
 read*, n
 print*, "Inserisci la frazione volumetrica delle nanoparticelle"
 read*, f
 if (x==1) then; ham = hamiltoncrosser(kp,0.613d0,n,f); else; ham = hamiltoncrosser(kp,0.253d0,n,f); endif
 print*, "Valore calcolato con la formula di Hamilton-Crosser:", ham
 print*, "Calcolo il valore con Kumar"
 print*, "Inserisci il valore della temperatura"
 read*, t
 print*, "Inserisci il valore del diametro medio nanoparticellare"
 read*, dp
 print*, "Inserisci il valore della viscosita' dinamica del fluido"
 read*, v

 if (x==1) then
  kum=kumar(t,dp,f,0d0,0.613d0,v)
 else
  kum=kumar(t,dp,f,0d0,0.253d0,v)
 end if

 print*, "Valore calcolato con la formula di Kumar:", kum
 print*, "Calcolo il valore con Prasher"
 print*, "Inserisci il valore della densita' della nanoparticella"
 read*, p

 if(x==1) then
  rey=reynolds(0.613d0,t,p,dp,v)
  pra=prasher(kp,0.613d0,f,prh2o,rey)
 else
  rey=reynolds(0.253d0,t,p,dp,v);
  pra=prasher(kp,0.253d0,f,preg,rey);
 endif
 print*, "Valore calcolato con la formula di Prasher:", pra

CONTAINS

 Function hamiltoncrosser(kp, kb, n, f)
  hamiltoncrosser=((kp+(((3d0/n)-1d0)*kb)-(((3d0/n)-1)*(kb-kp)*f))/(kp+(((3d0/n)-1)*kb)+((kb-kp)*f)));
 End Function

 Function reynolds(kb, t, p, dp, v)
  reynolds=sqrt((18d0*(kb*t))/(pi*p*dp))/v
 End Function

 Function kumar(t, dp, f, db, kb, v)
  kumar=(((((2*bolz*t)/(pi*v*dp*dp)))*((f*db/2)/(kb*(1-f)*(dp/2))))*c)+1;
 End Function

 Function prasher(kp, kb, f, pr, rey)
  prasher=((kp+(2*kb)+2*(kp-kb)*f)/(kp+(2*kb)-(kp-kb)*f))*(a*rey**m*pr**0.333*f)
 End Function

End Program hwup

Compaq Visual Fortran Professional Edition 6.6.0


ma 8 celle di excel no ?

[^TiGeRShArK^]

ma perchè li devi scrivere in fortran?
x quelle poche formule va benissimo anche un qualsiasi linguaggio di programmazione... o al limite anke Excel come ti è già stato suggerito

[a2000.1]

perchè Fortran è più da ... sborone !






questo poi è da VERY SBURONISSIMI !!!

[a2000.1]

certo che tutti quei cout, cin fanno cascare letteralmente le palle

[^TiGeRShArK^]

scriverlo in brainfuck sarebbe stato da sborone

[a2000.1]

il linguaggio di più basso livello per me è assfuck.

ma se per te è brainfuck un motivo ci deve essere !

[Warlord]

grazie millissimissime davvero !!!

Ho sistemato sto schifo di lavoro che avevo fatto ( molto incasinato per alcuni punti ) e sostituito la formula di kumar con 1 altra (koo) dopo che mi hai aperto il cervello realmente con la tua traduzione

uso compaq visual fortran 6.6 pure io ... cmq qui hai prprio ragione , 1 belfoglio di excel sarebbe bastato
per esempio ho scorporato la parte finale in :
-------------------------------------------------
program FormulaPrasher
implicit none
real reynolds ! Numero di Reynolds
real bolz ! Costante di Boltzman
integer t ! temperatura
real pi ! PiGreco
real p ! densita' nanoparticelle
real dp ! diametro medio nanoparticelle
real v ! viscosità dinamica fluido
real prasher
real kp ! conduttività nanoparticelle
real kb ! conduttività fluido base
real f ! frazione volumetrica
real m ! costante eq prasher dipendente dal liquido
real a ! cost eq prasher dipendente nanopart e fluido
real pr ! numero di Prandtl
integer nanoparticella
integer fluidobase

a = 4.0*(10**4)
pi = 3.1416
bolz = 1.38*(10**(-23))


write (*,*) 'Calcolo il valore della conduttività termica normalizzata del nanofluido'&
'usando la formula di Prasher'


! scelgo se usare acqua o EG
write (*,*) 'Desideri usare acqua o glicoletilenico?'&
'1) Acqua Demineralizzata'&
'2) Glicol Etilenico'
read (*,*) fluidobase

! scelgo il tipo di nanoparticella
write (*,*) 'Scegli il tipo di nanoparticellato da utilizzare'&
'1) Allumina'&
'2) Rame'&
'3) Ossido di rame'
read (*,*) nanoparticella

! richiedo il diametro medio delle nanoparticelle adoperate
write (*,*) 'Inserisci il diametro medio delle nanoparticelle in soluzione'
read (*,*) dp

! richiedo la temperatura a cui vogliamo operare (in gradi kelvin)
write (*,*) 'Inserisci la temperatura T a cui operare'
read (*,*) t

! richiedo la frazione volumetrica delle nanoparticelle presenti in soluzione
write (*,*) 'inserisci la frazione volumetrica delle nanoparticelle presenti in soluzione'
read (*,*) f

! implemento le caratteristiche a seconda del tipo di fluido scelto
if ( fluidobase == 1 ) then
kb = 0.613
v = 10.0**(-3)
m = 2.5
pr = 6.8
else
kb = 0.253
v = 21*(10**(-3))
m = 1.6
pr = 205.0
endif

! implemento le caratteristiche a seconda del tipo di nanoparticella scelta
if ( nanoparticella == 1 ) then
kp = 40.0
p = 3940.0
elseif( nanoparticella == 2 ) then
kp = 401.0
p = 8920.0
else
kp = 76.5
p = 6480
endif

! calcolo il numero di reynolds
reynolds =(1/v)*sqrt((18*bolz*t)/(pi*p*dp))

! calcolo coefficiente conduttività termica normalizzato secondo Prasher
prasher = ((kp+(2*kb)+2*(kp-kb)*f)/(kp+(2*kb)-(kp-kb)*f))*(1 + (a*reynolds**m)*(pr**0.333)*f)

write (*,*) 'la conducibilità termica della miscela nanofluidica scelta secondo la Formula di Prasher è' , prasher

end
-----------------------------------------

Ho messo implicit none perche' mi era piu' facile scovare l'errore
adesso vorrei implementare un ultima ultimissima cosa :
- funzione ( che ho scoperto essere "DO" in fortran ) per la frazione volumetrica f .... con 0 < f < 2
- che come output ci fosse 1 file di txt o 1 altro formato ( magari xls cosi' lo vado a pescare direttamente con excel , nn sapendo fare grafici con Visual Fortran ) o in generale un array con scritti a f scelto , il valore corrispondente trovato ( a partita ovviamente degli altri valori )

il DO penso di saperlo implementare con un po' di lavoro ma non saprei come dirgli "PRINT/WRITE su 1 caxxo di file "


grazie millissime ancora a2000.1 mi hai aperto le porte a un nuovo mondo !!!

[^TiGeRShArK^]

Originariamente inviato da a2000.1

il linguaggio di più basso livello per me è assfuck.

ma se per te è brainfuck un motivo ci deve essere !

brainfuck almeno esiste davvero

++++++++++
[
   >+++++++>++++++++++>+++>+<<<<-
]
>++. Loop iniziale (dopo viene stampata una H)
>+. e
+++++++. l
. l
+++. o
>++.
<<+++++++++++++++.
>.
+++.
------.
--------.
>+.
>.

Hello World scritto in quel linguaggio (preso da wikipedia ovviamente )...

[a2000.1]

anche Assfuck esiste: da Wikipedia:

Assfuck
Da Wikipedia, l'enciclopedia libera.
Assfuck è un linguaggio di programmazione per computer, di tipo massimalista, creato da Inurban Müller (quello dello yogurt) intorno al 1969. Il linguaggio viene in taluni casi denominato Assf*ck, Assf*** o anche soltanto AFYou&YourSister per evitare di offendere la sensibilità altrui.

Indice
1 Struttura del linguaggio 
   1.1 Istruzioni 
2 Esempi 
   2.1 FuckYou world! 
   2.2 Semplici 
      2.2.1 Loop semplice Up&Down around the hole
      2.2.2 Manipolazione dei puntatori AutoRecursiveFucktion
      2.2.3 Sommare
      2.2.4 Istruzioni condizionali: NoPay_NoPlay, NoMoney_NoHoney 
      2.2.5 Copiare un byte sono buoni tutti
   2.3 Complessi: LittlePenis procedure
      2.3.1 Somma: OnePlusOneEnhance  
      2.3.2 Moltiplicazione: 
3 Commento 
4 Vedere anche 
5 Collegamenti esterni

Struttura del linguaggio
L'obiettivo di Müller (sempre quello dello yogurt) era di creare un semplice linguaggio di programmazione completo per una macchina di AssTuring che potesse essere implementato con il compilatore più piccolo possibile ma se è grosso è meglio. Il linguaggio consiste di due istruzioni: dimme_lo e damme_lo. La versione 2 del compilatore originale, scritta per l'Amiga (quella gran f. di Fortaleza), occupa soltanto 240 byte ma tuuuuttti fino in fondo. È stato ispirato dal linguaggio Stica, un altro linguaggio di programmazione erotico, il cui compilatore occupava 1024 byte, ma solo a metà poverino.

Come il nome suggerisce, i programmi scritti in Assfuck tendono ad essere difficili da comprendere ma facili da sentire. Tuttavia Assfuck è un linguaggio AssTuring-completo in modalità AllHoleFilling , e si può utilizzare per implementare qualunque algo_ritmo eseguibile con una macchina di AssTuring. Trascurando l'enorme difficoltà nella programmazione di certi algoritmi genetici con ereditarietà con Assfuck, è certamente possibile scrivere il relativo codice bypassando certe delicate barriere implementative.

Il linguaggio è basato su un modello molto semplice consistente in un array di byte inizializzato a zero (detto 'corpo cavernoso'), un puntatore all'array (inizializzato per puntare al primo byte dell'array detto glande byte) e due stream di byte per l'input e l'output (ernesto e silvestro).

.....

[^TiGeRShArK^]

ehmm...
e perchè io non lo trovo con wikipedia?

(se lo crei ora tu non vale )

[a2000.1]

Originariamente inviato da ^TiGeRShArK^

ehmm...
e perchè io non lo trovo con wikipedia?

parchè ta zi un quaion !