View Full Version : "Ma quanto è INUTILE il FORTRAN 77" ????
KRYHAWOK
01-02-2002, 00:45
.... con una frase molto simile ha esordito la mia prof. di informatica, che non riusciva neppure a spiegare a sè stessa perchè nel programma delle lezioni fossero incluse una decina di ore sul Fortran_77.....
Da quel poco che ho visto è uno dei linguaggi più inutili, vecchi, astrusi, contorti che abbia mai visto...il Basic a confronto è una potenza divina!
OK, ammetto che in 10 ore di lezione (solo teoriche) non si può conoscere un linguaggio, ma vi garantisco che mi sono bastate. Ribadisco, è semplicemete INUTILE.
PS: fra 14 ore circa ho l'esame (anche) sul fortran e sono qui a postare... mah....
... e fai pure ingegneria (a Camerino ?)
(comunque aggiorniamoci almeno al Fortran90)
Tutta la programmazione in ambito matematico...supercomputer e simili...la fanno in Fortran...
Io ci ho fatto una parte della tesi, basata sul calcolo numerico. In quell'ambito serve ancora eccome. In effetti ci lavorano ancora in parecchi e non solo per nostalgia...
KRYHAWOK
01-02-2002, 20:22
Quello che non riesco a capire (sempre in base a quel poco che so di Fortran) è che cosa abbia in più del Pascal, C, C++ ecc..
Sicuramente la pura gestione numerica è più rapida col F_77, ma bisogna pagare moltissimo in termini di flessibilità, forse troppo.
La "pura gestione numerica" è TUTTO.
E' importante avere un linguaggio che generi eseguibili veloci (ma anche altri linguaggi lo fanno) e che soprattutto sia quanto più simile al linguaggio algebrico = FORmula TRANslator.
Poi, per fare dei rettangoli colorati dentro un rettangolone più grande (schermo) puoi usare un VisualX qualunque.
manseeverard
02-02-2002, 21:34
In piu' degli altri linguaggi ha una gestione efficientissima della memoria. Certo, non e' elegante dal punto di vista della programmazione, ma quando si cerca l'efficienza pura non si puo' anche pretendere la comodita' nella programmazione (esempio: java=comodita', fortran=efficienza)
/\/\@®¢Ø
02-02-2002, 23:27
Oltre a quanto gia' scritto, altri motivi per cui Fortran e' ancora usato se non sbaglio sono : librerie preesistenti molto efficienti, il fatto che in ambito scientifico e' ancora molto conosciuto e quindi puo' essere sfruttato piu' efficacemente che non altri linguaggi, e ( per il F77 ) la sua semplicita' e l'assenza di puntatori che permette a compilatori opportuni di analizzare il codice e parallelizzarlo in maniera automatica, e in certi ambiti, dove si utilizzano supercomputer con decine ( o anche centinaia ! ) di cpu, e' la manna dal cielo.
KRYHAWOK
04-02-2002, 18:10
Ok, mo ci siamo. Grazie delle spiegazioni.
byezz
il FORTAN è oggi INUTILE per chi comincia a programmare ed ha solo un valore "storico", questo non vuol dire che non abbia avuto una funzione importante in passato.
mi chiedo invece quanti linguaggi recenti sono inutili specie i vari script language ASP PHP CGI JAVA JAVASCRIPT VISUALSCRIPT TCL per citare solo i piu' famosi, qualcuno dice che è meglio averne tanti che pochi...io non sono daccordo a riguardo.
CGI e ASP non corrispondono ad un linguaggio...
si è vero...ad ogni modo richiedono una sintassi di programmazione ben precisa e articolata, allora....
Originariamente inviato da homero
[B]si è vero...ad ogni modo richiedono una sintassi di programmazione ben precisa e articolata, allora....
CGI (Common Gateway Interface) descrive le modalità di funzionamento del passaggio dei dati fra una pagina web ed una applicazione esterna (che rende dinamica la pagina web di risposta)...
ASP è una piattaforma per lo sviluppo di applicazione web...
Supporta lo sviluppo in VBScript o JavaScript
La versione .net dovrebbe supportare oltre a questi due anche C# e C++...se non sbaglio...
Scusate, ma se volete determinare i campi di velocità, pressione, temperatura e composizione sopra Milano o nella camera di combustione di un motore a scoppio o in un reattore chimico o nel case del vostro computer cosa utilizzate Java Script, C++ o un linguaggio il più possibile simile al linguaggio con cui sono scritte le equazioni che descrivono i principi di conservazione di massa energia e quantità di moto ?
Poi, dal punto di vista fondamentale della SCRITTURA, di quello che si VEDE quando leggo un codice OO, tutte le 'meraviglie' della programmazione ad oggetti derivano da una semplice regola di naming: battezzo tutte le variabili, le costanti, le procedure, le funzioni, gli eventi attinenti allo stesso oggetto con lo stesso cognome.
Ma questa è una buona regola formale che posso (devo) usare anche in linguaggi non OO, con la sola differenza che uso l'underline invece del punto e non mi diverto a parlare di classi e loro istanze e di ereditarietà e di incapsulamento.
Ad ogni modo, se si riesce a tradurre in modo più o meno automatico da un linguaggio naturale ad un altro, si può tranquillamente tradurre con poco più che un editor di testo da un linguaggio di programmazione ad un altro.
La clausola che alcune caratteristiche intrinseche tipo ricursività, allocazione dinamica, ecc. devono essere per forza implementate nel linguaggio è solo apparente: basta scrivere un codice che scrive codice (o modifica se stesso).
Quello che voglio dire è che un linguaggio di programmazione è solo un vestito formale che deve essere quanto più simile al linguaggio naturale con cui certi problemi sono stati affrontati.
E quindi chi si occupa di fisica, chimica, ingegneria ecc. pensa in termini matematici e scrive in Fortran.
Poi, dopo analisi numerica, per passare al C++ si può sempre tenere lo Stroustroup sul comodino ...
KRYHAWOK
06-02-2002, 20:46
Può anche essere... ma a me viene 200 volte + naturale scrivere in C++ (a parte quando tento di dichiarare array 3x3 con int a[2][2] ...:D) che in fortran. La stessa modalità con cui gestisce l'output rende il codice molto meno leggibile di quanto possa essere un listato C++ non mastodontico.
L'unica cosa che mi farebbe usare il fortran sarebbe avere dati da calcolare e visualizzare con una precisione assoluta... ma questo mi pare un compromesso eccessivo rispetto alla perdita di flessibilità, punto di forza C++ (che si usino oggetti o meno).
Originariamente inviato da a2000
[B]Poi, dal punto di vista fondamentale della SCRITTURA, di quello che si VEDE quando leggo un codice OO, tutte le 'meraviglie' della programmazione ad oggetti derivano da una semplice regola di naming: battezzo tutte le variabili, le costanti, le procedure, le funzioni, gli eventi attinenti allo stesso oggetto con lo stesso cognome.
Ma questa è una buona regola formale che posso (devo) usare anche in linguaggi non OO, con la sola differenza che uso l'underline invece del punto e non mi diverto a parlare di classi e loro istanze e di ereditarietà e di incapsulamento.
Non sono affatto d'accordo...che fine fanno ereditarietà (che non è divertente, ma utile, soprattutto per riusare codice non scritto da te), polimorfismo... Sono concetti che rendono la programmazione + semplice e veloce....
KRYHAWOK
06-02-2002, 22:12
Originariamente inviato da cionci
[B]
Non sono affatto d'accordo...che fine fanno ereditarietà (che non è divertente, ma utile, soprattutto per riusare codice non scritto da te), polimorfismo... Sono concetti che rendono la programmazione + semplice e veloce....
Sottoscrivo in pieno.
Quando ho scritto le mie prime righe di codice (Basic sul C64 in 1a media...) non avevo la minima idea di cosa fosse la programmazione a oggetti. Ma ora che, da poco, so esattamente di cosa si tratta, mi paiono uno strumento formidabile: pensa solo alla versatilità dei Template e alla loro potenza.
Inoltre, è 100 volte + facile gestire vecchi programmi scritti con le classi che senza.. ancor più se devi operare su un codice che non hai scritto personalmente, ma semplicemente piegare alle tue esigenze classi/template e similia realizzate da altri.
/\/\@®¢Ø
06-02-2002, 22:36
Originariamente inviato da KRYHAWOK
[B] pensa solo alla versatilità dei Template e alla loro potenza.
In effetti i template nulla hanno a che vedere con la programmazione ad oggetti. ( Esistono linguaggi di programmazione che forniscono i primi ma non la seconda ). Anzi in un certo senso sono tra loro ortogonali, e si completano a vicenda.
Poi, per curiosità, si può sempre fare un prodotto righe per colonne per vedere quale linguaggio se la cava meglio.
Originariamente inviato da a2000
[B]Poi, per curiosità, si può sempre fare un prodotto righe per colonne per vedere quale linguaggio se la cava meglio.
Io ci sto...vediamo quale compilatore è + veloce ?
Dimmi un po' le dimensioni delle matrici iniziali e del risultato...
KRYHAWOK
09-02-2002, 02:59
Originariamente inviato da cionci
[B]
Io ci sto...vediamo quale compilatore è + veloce ?
Dimmi un po' le dimensioni delle matrici iniziali e del risultato...
Sfidone? Ci sto!
Originariamente inviato da KRYHAWOK
La stessa modalità con cui gestisce l'output rende il codice molto meno leggibile di quanto possa essere un listato C++ non mastodontico.
Sono d'accordo, ma non trascuriamo il problema del codice legacy.
Ovvero delle *centinaia di migliaia* di righe di codice fortran che ci sono in giro, la maggior parte delle quali testata e ottimizzata.
Per buttarla via ci devono essere davvero *ottimi* motivi...
(Nota: la parte che fa i calcoli matematici veri e propri in octave -semiclone free di Matlab- e' proprio in F77)
perdita di flessibilità, punto di forza C++ (che si usino oggetti o meno).
Ma infatti il fortran non e' un linguaggio general-purpose, al contrario del C++ ;) [AFAIK!]
KRYHAWOK
09-02-2002, 14:05
Condivido che il fortran 77 possa servire laddove serva codice fortemente ottimizzato per velocizzare il calcolo matematico: cmq penso sia indubbio che sia un linguaggio "vecchio" come concezione in senso lato (sempre escludendo la parte sugli oggetti), come "mentalità" di scrittura del codice. Che poi dia ottimi risultati in termini di puro calcolo posso crederci, ma presumo che venga sfruttato a dovere solo in caso di operazioni davvero complesse.
Non sono comunque abbastanza esperto per poter quantificare la reale differenza di velocità che può esserci tra il F77 e il C++.
1000x1000, doppia precisione
tempo di calcolo = 2.34 s
Dai, come fanno ad essere 2,36 secondi...è impossibile...
Sinceramente 2,36 secondi per oltre 3 miliardi di operazioni mi sembrano un po' pochini...
Quante cose ti potrei rispondere ... tutte in amicizia, per carità.
Ma non siete voi quelli dei puntatori, dell' i++ in stack, del C che controlla tutte le funzioni di macchina, con cui puoi gestire registro per registro, quasi come con l'assembler? (a proposito, te lo ricordi il proto-assembler dell'hp42 o sei troppo giovane?)
Bene, do it.
Vedi ... ,solo che adesso non ho tempo, ... a forza di fare codici leggibili, con routine (pardon, classi) che fanno poche cose ben definite, dati incapsulati, con interfacce esplicite (tutti i parametri passati by value, per carità), si guadagna in componibilità, modularità, riutilizzabilità, ma si perde in ... velocità ? no, in bellezza.
E' la stessa differenza che passa tra un ponte fatto con due pali e una traversa (oggetti modulari, autosufficienti, componibili) e uno fatto di archi e volte per cui se togli un pezzo, viene giù tutto, ma AT ALL (e se stà in piedi, è vero) quanto è più forte, leggero, bello.
[Per non parlare dei raggi B davanti ai contrafforti di Orione (è patologia, lo ammetto) dei codici assembler che sparano sull'area di memoria del codice.]
Comunque confermo, tempo di calcolo = 2.34 s, non ho specificato nè CPU (una CPU, non PC cluster), nè OS, perchè sò che hai tempi tre volte un ordine di grandezza e quindi che sia Tb1000 o XP2000+ è lo stesso.
Ad ogni modo ti do un paio di suggerimenti: tieni conto che il Fortran memorizza per colonne e il C++ per righe (a meno di qualche setting); riduci al minimo il calcolo degli indirizzi e ...
vabbè ma non ti posso dire tutto ....
Ciao.
[QUOTE]Originariamente inviato da a2000
si guadagna in componibilità, modularità, riutilizzabilità, ma si perde in ... velocità ? no, in bellezza.
E' la stessa differenza che passa tra un ponte fatto con due pali e una traversa (oggetti modulari, autosufficienti, componibili) e uno fatto di archi e volte per cui se togli un pezzo, viene giù tutto, ma AT ALL (e se stà in piedi, è vero) quanto è più forte, leggero, bello.
Personalmente non sono *assolutamente* d'accordo, ma credo che sia per la mia inesperienza.
ma siete corregionali di Leonardo da Vinci (un grande della sintesi)o di Cecchi Gori (un glande dell'ana_lisi) ?
Io ho tempi dell'ordine di 100 secondi (il sistema di memorizzazione me lo sono fatto da solo, comunque ho già diverse idee per l'ottimizzazione)...con un Tb1000...
Mi passeresti l'eseguibile...voglio farci un po' di reverse engineering...
KRYHAWOK
11-02-2002, 12:29
Che versione del fortran hai usato? Quale compilatore?
Esatto: "tre volte un'ordine di grandezza" = 2.34 * 3 * 10 *1400/1000 = 98.28 s (io ho un Tb1400).
Vedo con piacere che, piano piano, ti stai avvicinando alla filosofia Fortran e allora prima della pappa pronta (.f90), ti darò un'altro suggerimento: accumula righe e colonne in vettori ausiliari (pochi).
Ve l'ho detto se il Fortran fosse solo un linguaggio sarebbe già stato sostituito, è invece uno 'stile' di programmazione e SOPRATTUTTO un marchio di appartenenza.
D'altra parte, cosa vuoi, l'apporto proteico (linguaggio macchina) lo pò fornire sia la mortadella (C++) che il prosciutto di Parma (Fortran).
Ma il prosciutto di Parma è il prosciutto di Parma (poi c'è qualche 'periferico' che preferisce il San Daniele: Pascal)
E col prosciutto di Parma si può fare un'ottima mortadella.
Il problema non è il C++ ma lo 'stile' (in senso lato) dei suoi abitanti.
Per il giovane guerriero celtico (attento ai Tessitori di Sogni ...) se proprio ti scappa di programmare in C++ per le cose serie, fai la cosa giusta, fallo in modo serio:
G. Buzzi-Ferraris
Metodi Numerici e Software in C++
Addison-Wesley
(forse è uscito anche il II volume)
dello stesso autore:
Dal Fortran al C++
Questo ti consiglio di leggerlo due volte: la prima dall'ultima pagina alla prima (dal C++ al Fortran) così, per disintossicarsi.
Ah dimenticavo, il compilatore: un onestissimo FortranPower Station 4.0
Saluti.
Non vi sarete mica offesi ...
Su, su, avere idee diverse è l'igiene del mondo ...
o vi piace il pappa e Ciccia nazionale.
Come và l'ottimizzazione ?
Sono riuscito ad arrivare a 35 secondi...di meglio per ora non sono riuscito a fare...
Esatto: "tre volte un'ordine di grandezza"
Non e' una sorpresa, IMHO... Che il fortran sia quasi imbattibile per il number crunching e' ormai noto ;)
Vedo con piacere che, piano piano, ti stai avvicinando alla filosofia Fortran e allora prima della pappa pronta (.f90)
Non credo che la voglia di sbattersi sia esclusiva dei programmatori Fortran (vedi sotto)
SOPRATTUTTO un marchio di appartenenza.
...Questo e' positivo o negativo?
E col prosciutto di Parma si può fare un'ottima mortadella.
Non lo metto in dubbio (anzi, ad esser sincero qualche perplessita la ho, ma il fortran lo conosco solo di nome e di fama
per cui risparmio...), ma mi pare di capire che per te il Fortran e' il RE dei linguaggi di programmazione... A costo di dire una (grossa) banalita', personalmente ritengo che per ogni cosa ci sia un perche': se il Fortran e' ancora vivo e vegeto, deve avere necessariamente i suoi innegabili punti di forza. Non a caso alcune delle "truppe ca++ellate" sono subito venute in soccorso del venerando Fortran.
Infine, non mi pare granche' furbo -ma ripeto, e' solamente un'opinione personale dettata dalla mia scars(issim)a esperienza- voler usare uno stesso strumento per molti compiti diversi: fatica inutile. Per farmi un batch in console uso script di BASH, non sto certo a scomodare C + API o peggio C++... (esempio stupido)
Il problema non è il C++ ma lo 'stile' (in senso lato) dei suoi abitanti.
Ovvero?
Non sara' che buona parte delle prestazioni in piu' del fortran (all'infuori degli indubbi meriti oggettivi) lo fanno gli algoritmi utilizzati e la maggiore perizia (in una parola: lo stato mentale... quel marchio suddetto) dei programmatori?
Ma questa, (per fortuna!) non e' una qualita' esclusiva del fortran, e si applica (quasi) egualmente bene al 99% dei linguaggi sulla terra...
Ah dimenticavo, il compilatore: un onestissimo FortranPower Station 4.0
A titolo di curiosita' personale, sarei curioso di sapere come se la cavano g77, gcc e g++ in questo frangente.
In particolare, la mia prima idea e' che g++ e gcc se ne starebbero quasi appaiati.
Bene.
Onesti, bravi, preparati.
Forse dovrò ricredermi ...
La classe (mò ci vuole) non è acqua,
e avere vent'anni sì: acqua limpida e allegra,
inconsapevole del mare aperto
o di uno stagno di fango.
Buonanotte.
KRYHAWOK
13-02-2002, 01:58
Originariamente inviato da a2000
[B]Bene.
Onesti, bravi, preparati.
Forse dovrò ricredermi ...
:eek: :eek: :eek:
Si va beh,
ma poi ... dico ... l'esame ... ... l'hai passato o no ?
O t' hanno tromb ..., sorry, boCCiato proprio sul Fortran, o magari sul C pus pus !
Ma sta Prof. ... quanti anni ha? Magari 77 !
Allora è un lapsus freudiano: voleva dire " ma quanto MI è inutile a 77 anni !"
Il libro l'hai comprato ?
Guarda che il tipo è uno nostro
Ma nostro di chi? dici tu.
Nostro, nostro ...
Originariamente inviato da a2000
O t' hanno tromb ..., sorry, boCCiato proprio sul Fortran, o magari sul C pus pus !
-------------------------------------------------------------------------^^^^^^
Me la spieghi, questa?
Eh, lo sò, forse non è proprio politically correct, però ... ogni tanto ... bisogna svariare.
Diciamo che mi sono ispirato al tuo conte Uguccione.
Comunque stavo parlando al giovane guerriero celtico.
Spero non se la prenda.
Ciao.
Originariamente inviato da a2000
Eh, lo sò, forse non è proprio politically correct, però ... ogni tanto ... bisogna svariare.
Diciamo che mi sono ispirato al tuo conte Uguccione.
Non e' questione di Politcally correct, di cui semplicemente non me ne po' frega' de meno. Vorrei semplicemente sapere quali sono le tue ragioni contro il C++.
Visto che pochi post piu' sopra dici che il problema non e' tanto nel linguaggio ma negli utenti...
Nota: il C++ NON e' il mio linguaggio di programmazione preferito.
KRYHAWOK
13-02-2002, 18:52
"il giovane guerriero celtico" riferisce di non aver ancora comprato altri libri; l'esito dell'esame ce l'avrà il 20 di questo mese.
Quanto al C++, sto ancora spulciando lo Shildt.
Quanto al Fortran, mah... mi fa venire in mente al massimo il cemento Portland, con cui almeno fai stare in piedi un bel muretto....
Originariamente inviato da KRYHAWOK
Quanto al C++, sto ancora spulciando lo Shildt.
!!!
OCCHIO! quel libro e' SCONSIGLIAT(ISSIM)O da molti recensori e su molti gruppi: contiene, pare, parecchie inesattezze anche gravi.
Personalmente manco l'ho visto, quel libro, ma le fonti sono abbastanza attendibili (E mi sono trovato benissimo col Lippman)
KRYHAWOK
13-02-2002, 19:30
Originariamente inviato da Ikitt
Originariamente inviato da KRYHAWOK
[B]Quanto al C++, sto ancora spulciando lo Shildt.
!!!
OCCHIO! quel libro e' SCONSIGLIAT(ISSIM)O da molti recensori e su molti gruppi: contiene, pare, parecchie inesattezze anche gravi.
Personalmente manco l'ho visto, quel libro, ma le fonti sono abbastanza attendibili (E mi sono trovato benissimo col Lippman)
Quello che ho io è "guida completa al C++", seconda ed. McGraw-Hill. Non è il massimo come suddivisione degli argomenti e non si spinge assolutamente nella programmazione avanzata. Va bene penso solo per cominciare a masticare il C++. Non ho mai visto il Lippman, sorry.
Cazpita KRYHAWOK,
ma non ti dice proprio bene.
Come, mi fai il Pierino con lo Shildt e track! ti dicono subito che è sconsigliatissimo ...
Stammi a sentire: non confondere i CA++I con gli EQUINOZI (G.Marquez, Cent'anni di solitudine, Einaudi), tu non devi programmare Le avventure di Spyro per la PlayStation 2 (lo so che hai fatto un mutuo per comprarla), tu devi risolvere il divT = 0 con T = aI + 2uD, ossia determinare lo stato di sforzo e deformazione in strutture qualsivoglia (anche il muretto che hai fatto con la paletta rossa e il secchiello).
Facciamo un pò i seri senno qui ci chiudono.
Allora, diamo un esito alla storia del prodotto righe per colonne.
CODICE NAIVE: tempo di calcolo tc = 41.6 s
E’ la trasposizione tal quale della formula di calcolo.
Il tempo di calcolo stimato su Tb1000 pari a 41.6*1400/1000 = 58.24 s è nettamente inferiore ai 100 s del NAIVE (I suppose) su C++.
Do i = 1, II
Do j = 1, JJ
cij = 0d0
Do k = 1, KK
cij = cij + a(i, k) * b(k, j)
End Do
c(i, j) = cij
End Do
End Do
CODICE NAIF: tempo di calcolo tc = 45.7 s
Dove si dimostra come il calcolo degli indirizzi delle matrici, pur essendo effettuato con interi da 2 byte, è molto oneroso.
L’errore “naif” di non utilizzare una singola variabile ausiliaria di somma cij viene pagato con un’ aumento del tempo di calcolo del 10%.
Do i = 1, II
Do j = 1, JJ
c(i, j) = 0d0
Do k = 1, KK
c(i, j) = c(i, j) + a(i, k) * b(k, j)
End Do
End Do
End Do
CODICE TIME OPTIMIZED: tempo di calcolo tc = 2.34 s
Ecco svelato l’arcano …
Due idee guida:
1) Ridurre al minimo il calcolo degli indirizzi tramite l’uso di variabili e vettori ausiliari di catasta (stack) virtuale.
2) Permettere al compilatore di ALLOCARE la porzione di codice in esecuzione e TUTTE le variabili di calcolo (che a questo punto sono state ridotte alle variabili e ai vettori ausiliari), nelle memorie veloci: registri di stack e memoria cache: questo sì che si chiama incapsulamento (hardware).
Due versioni, nella prima, più compatta, si utilizza soprattutto l’accumulo di righe e colonne in vettori ausiliari di stack (punto 2): tempo di calcolo = 4.64 s.
Nella seconda si riduce anche il calcolo degli indirizzi (punto 1) : tempo di calcolo = 2.34 s.
Anche il codice della seconda versione è assolutamente generale, il numero dei vettori di stack può essere determinato in relazione alle dimensioni delle matrici con semplici istruzioni di controllo esterne alla routine o, meglio ancora, con meta-comandi di compilazione.
Versione 1
Do i = 1, II, 10
Do ih =0, 9
aa(1:KK, ih) = a(i+ih, 1:KK) !estrazione sottomatrice di a (10 righe)
End Do
Do j = 1, JJ, 10
Do jh =0, 9
bb(1:KK, jh) = b(1:KK, j+jh) !estrazione sottomatrice di b (10 colonne)
End Do
!bb(1:KK, 0:9) = b(1:KK, j:j+9) !estrazione sottomatrice di b (10 colonne) [opzionale]
Do ih = 0, 9
ai = aa(1:KK, ih)
Do jh = 0, 9
cij = 0d0
Do k = 1, KK
cij = cij + ai(k) * bb(k, jh)
End Do
c(i + ih, j + jh) = cij
End Do
End Do
End Do
End Do
Versione 2
Do i0 = 1, II, 10
i1=i0+1
i2=i0+2
…
i9=i0+9
a0 = a(i0, 1:KK)
a1 = a(i1, 1:KK)
…
a9 = a(i9, 1:KK)
Do j0 = 1, JJ, 10
j1=j0+1
j2=j0+2
…
j9=j+9
b0 = b(1:KK, j0)
b1 = b(1:KK, j1)
…
b9 = b(1:KK, j9)
c00 = a0(1) * b0(1)
c01 = a0(1) * b1(1)
…
c98 = a9(1) * b8(1)
c99 = a9(1) * b9(1)
Do k = 2, KK
c00 = c00 + a0(k) * b0(k)
c01 = c01 + a0(k) * b1(k)
…
c98 = c98 + a9(k) * b8(k)
c99 = c99 + a9(k) * b9(k)
End Do
c(i0, j0) = c00
c(i0, j1) = c01
….
c(i9, j8) = c98
c(i9, j9) = c99
End Do
End Do
CODICE LESS CODE OPTIMIZED: tempo di calcolo tc = 44.2 s
E per finire, una versione orientata alla riduzione all’osso delle righe di codice.
E sì, una volta si faceva anche a chi ce l’aveva più corto.
Il codice utilizza le nuove features sintattiche del Fortran90:
Do i = 1, II
Do j = 1, JJ
c(i, j) = Sum(a(i, 1:KK) * b(1:KK, j))
End Do
End Do
Tutto qui.
Per i noti motivi, meglio così:
Do i = 1, II
ai = a(i, 1:KK)
Do j = 1, JJ
c(i, j) = Sum(ai * b(1:KK, j))
End Do
End Do
MORALE
La programmazione vera e "native" è quella che si fà in ambito tecnico-scientifico è ha come base l'analisi numerica.
La si può fare in Pascal, in Basic, in C, in C++, in Assembler, la si è fatta sempre, e alla stragrande, in FORTRAN.
Tutto il resto (tutto il dato-manipolismo): data-query, protocolli di trasmissione, pagine web, software di gestione, forms, text-box, grid, buttons, carico e scarico magazzino ... lo potete fare come vi pare, anche no.
Però .... massimo rispetto per i parenti di sangue blù.
Tutto quello che vi passa per le mani (quasi tutto, spero) è "passato" attraverso codici Fortran: auto, televisori, la plastica della paletta rossa di vostro figlio, l'insalata che mangiate, la pasta, l'aria che respirate (purtroppo), la paura di finire tutti vaporizzati a 10000 gradi, la paura di essere "ascoltati", ma anche il sole "previsto" di un fine settimana di maggio con la morosa.
Buonanotte.
KRYHAWOK
14-02-2002, 00:37
Originariamente inviato da a2000
[B]Cazpita KRYHAWOK,
ma non ti dice proprio bene.
Come, mi fai il Pierino con lo Shildt e track! ti dicono subito che è sconsigliatissimo ...
Stammi a sentire: non confondere i CA++I con gli EQUINOZI (G.Marquez, Cent'anni di solitudine, Einaudi), tu non devi programmare Le avventure di Spyro per la PlayStation 2 (lo so che hai fatto un mutuo per comprarla), tu devi risolvere il divT = 0 con T = aI + 2uD, ossia determinare lo stato di sforzo e deformazione in strutture qualsivoglia (anche il muretto che hai fatto con la paletta rossa e il secchiello).
Eh.. hai ragione.. ma noi gente del classico amiamo le cose complicate; anzi, più lo sono più ci divertiamo a risolverle; accidenti! ci mancava pure la sfortuna di un libraccio scadente... lo sapevo che dovevo continuare a programmare sul C64 in Basic.
Come mi hai fatto ricordare, ero proprio indeciso se comprarmi la Playstation 2 o il Fortran_77, che sono da sempre stati i miei più grandi amori... poi mi è tornato in mente il buon vecchio Socrate: "l'uomo più saggio è colui che sa di non sapere".. e, a questo punto, come avrei potuto dargli torto? Per questo, ho rinunciato a fare quei due formidabili acquisti in virtù dell'ignoranza concessami dal mio adorato Nintendo 8 bit e da quel... come si chiama.. mah... ....C++, ecco era lui.
Sono stati giorni bui per la mia mente, e da allora sto ancora dormendo un'unica grande notte...
PS: porca miseria! mi hai fatto ricordare che ho sbagliato il rapporto a/c del mio muretto! L'incompetenza....
Complimenti per l'ottimizzazione!
Ca++o, m'hanno tolto l'indentazione!
KRYHAWOK
14-02-2002, 00:40
MORALE
Ora ho sonno.
KRYHAWOK
14-02-2002, 00:41
Originariamente inviato da a2000
[B]Ca++o, m'hanno tolto l'indentazione!
Cos'hai perso? Non posso coricarmi senza sapere cosa ti affligge!
Ma sei ancora sveglio, a quest'ora.
Lorenzo e Ilaria sono già a letto da un pezzo.
Guarda che domani mattina la professoressa Fortrani ti interroga sul capitolo, anzi sulla posizione, 645 dello Stroustroup
(il Kamasutra di programmatori, anzi no, programmatori è obsolescent, sviluppatori, come quelli dei Sex Shop).
Fai la pipì e fila a letto!
KRYHAWOK
14-02-2002, 00:52
Originariamente inviato da a2000
[B]Ma sei ancora sveglio, a quest'ora.
Lorenzo e Ilaria sono già a letto da un pezzo.
Guarda che domani mattina la professoressa Fortrani ti interroga sul capitolo, anzi sulla posizione, 645 dello Stroustroup
(il Kamasutra di programmatori, anzi no, programmatori è obsolescent, sviluppatori, come quelli dei Sex Shop).
Fai la pipì e fila a letto!
Meno male che mi hai insegnato i trucchi del mestiere: la Fortrani sarà umiliata dalla mia nuova concezione del sapere informatico!
Andrò a letto un po' turbato, poichè conscio che ogni giorno, su questo thread, si scrive la nuova storia del pensiero umano!
PS: non devo fare la pipì, ma solo lavarmi i dentini.
Cordiali saluti.
Saluti cordiali.
(nel senso che adesso mi sparo un nocino e quant'altro)
Io sono risucito s calcolare una versione ottimizzata un po' diversa.
In partica ho notato come evolvono gli indici durante la moltiplicazione...
Ho emmorizzato la matrice in un vettore (anche se grazie all'overloading l'utente esterno ci può accedere nel modo classico m[i][j])...ad esempio, l'indice 5 in una matrice 3x3 indica il l'elemnto (1,2) (ricordo che gli indici partono da 0 in C/C++)
In pratica per una moltiplicazone (2x3)*(3x2) = (2x2) si ottengono questi indici :
1 2 3
0 0 0
1 2 0
2 4 0
0 1 1
1 3 1
2 5 1
3 0 2
4 2 2
5 4 2
3 1 3
4 3 3
5 5 3
Per otenere una progressione più semplice degli indici (per ottenere bisognava fare una moltiplicazione e poi una somma) li ho riordinati in questo modo :
1 2 3
0 0 0
0 1 1
1 2 0
1 3 1
2 4 0
2 5 1
3 0 2
3 1 3
4 2 2
4 3 3
5 4 2
5 5 3
Mi calcolo il momento del ciclo totale (è un unico ciclo e quindi un solo incremento per ciclo) in cui devo cambiare gli indici in 2 vettori distinti (mi bastano 2 vettori perchè ottengo il momento in cui devo cambiare il 3o indice congiuntamente dal secondo e dal primo)...
Lavoro solamente sui puntatori quindi non c'è bisogno di ricalcolare la posizione ogni volta che si accede ad una matrice...
Nel ciclo principale ci sono 2 if che controllano l'equivalenza fra l'indice del ciclo principale ed una posizione in cui bisogna effettuare un cambio (e quindi modificare i puntatori)...
Che te ne sembra ?
Mi spighi un po' meglio il fatto dell'estrazione della matrice 10x10 ? Fai la moltiplicazione fra 2 matrici 10x10 ogni volta ?
Ciao
Non so se, mantenendo le matrici bidimensionali, si riesce a fare il calcolo degli indirizzi (con routine di linguaggio ad alto livello) meglio di quanto faccia il compilatore.
Comunque questa è una capabilities del C ed è giusto provare anche questa strada.
Sì, in sostanza accumulo n (10) righe della matrice a, e m (10) colonne della b in vettori ausiliari e ne faccio la somma dei prodotti termine a termine.
Con il governo delle singole locazioni di memoria, si potrebbe, forse, fare di meglio.
Senza entrare nei dettagli dovresti pensare a due aree di memoria (contigue e cache) in cui memorizzi n righe di a (aa) e m colonne di b (bb) e poi fai il prodotto termine a termine delle prime KK locazioni di aa con TUTTE le locazioni di bb a blocchi di KK.
Poi dai un'offset di KK all'indirizzo base di aa (ossia passi alla riga successiva) e così via.
Tieni conto comunque che i compilatori avanzati per il calcolo numerico, tutte queste procedure di ottimizzazione le creano automaticamente se gli si dà agio di farlo (e per questo che bisogna utilizzare le variabili ausiliarie di accumulo).
Non ne sono sicuro, ma suppongo che ci siano anche, trasparenti, algoritmi di IA.
Insomma, fai conto che sei su un'aereo in cui non sei più il pilota ma solo un passeggero che ha comprato il biglietto di destinazione.
Poi il percorso (migliore ?) lo decide il pilota automatico (compilatore).
Ciao.
Trasponendo la matrice di destra della moltiplicazione sono arrivato ad una soluzione discreta...risultato 19,3 secondi...
template<class TIPO>
matrice<TIPO> matrice<TIPO>::operator*(matrice<TIPO> &m2)
{
m2.trasponi();
matrice<TIPO> m3(r,m2.c);
register TIPO *i = m3.m;
register TIPO *imax = m3.m + r*m2.c;
register TIPO *p, *p2;
TIPO *pbase;
p2 = m2.m;
p = m;
pbase = m;
register TIPO* pmax = p + r;
TIPO* p2max = p2 + m2.r * m2.c;
for(; i<imax; ++i)
{
for(p=pbase; p<pmax; ++p)
*i += *p * *(p2++);
if(p2 == p2max)
{
p2 = m2.m;
pmax += r;
pbase = p;
}
}
m2.trasponi();
return m3;
}
Questa funzione qua sopra è utilizzabile con qualsiasi tipo di formato numerico e con matrici di qualsiasi dimensione, anche rettangolari...
a2000 : qual'è il risultato ottenibile con il Fortran mantendendo la funzione che calcola il prodotto il + generica possibile (cioè senza dipendere dalle dimensioni delle matrici e valida anche per matrici rettangolari) ?
Aggiornamento...con una semplice modifica ecco 12,3 secondi !!!
template<class TIPO>
matrice<TIPO> matrice<TIPO>::operator*(matrice<TIPO> &m2)
{
m2.trasponi();
matrice<TIPO> m3(r,m2.c);
register TIPO *i = m3.m;
TIPO *imax = m3.m + r*m2.c;
register TIPO *p, *p2;
TIPO *pbase;
p2 = m2.m;
p = m;
pbase = m;
register TIPO *pmax = p + r;
TIPO* p2max = p2 + m2.r * m2.c;
register TIPO tmp;
for(; i<imax; ++i)
{
tmp = 0;
for(p=pbase; p<pmax; ++p)
tmp += *p * *(p2++);
*i = tmp;
if(p2 == p2max)
{
p2 = m2.m;
pmax += r;
pbase = p;
}
}
m2.trasponi();
return m3;
}
Bene, bravo.
No, guarda che i codici che ho postato sono assolutamente generali, anche per matrici rettangolari di qualunque dimensione.
D'altra parte, lo sai, la generalità è una fissa di chi ha una formazione da analisi matematica e calcolo numerico.
Anzi, genera la patologia per cui il caso particolare, il singolo progetto, il contrattino viene scartato con grave danno all'economia familiare ...
Anche quello che estrae le matrici di 10 elementi è generale ?
sì anche quello.
ci credi sulla parola o vuoi vedere quello che voi Cplusplani non potete neanche immaginare ...
a proposito, guarda cosa ti fano 25 righe di codice in ... Fortran ?
no, VBA.
clicca sull'uovo!
KRYHAWOK sei silenzioso stasera.
che hai fatto piccolino ... sei arrabbiato ?
Originariamente inviato da a2000
ci credi sulla parola o vuoi vedere quello che voi Cplusplani non potete neanche immaginare ...
...E viceversa, ovviamente ;)
Anche se non capisco questa tendenza a voler inquadrare le persone (pardon, i programmatori)...
Sara' l'inesperienza della giovine eta'...
KRYHAWOK
15-02-2002, 01:12
Originariamente inviato da a2000
[B]KRYHAWOK sei silenzioso stasera.
che hai fatto piccolino ... sei arrabbiato ?
Scusa, mamma, ma ero addirittura finito tra la marmaglia di off-topic stasera; anzi, data la tua saggezza, vorrei che dessi un'opinione alla discussione che ho aperto qui: http://forum.hwupgrade.it/showthread.php?s=&threadid=209036
Purtroppo tu e cionci avete più esperienza del povero umile C++ista qui presente, quindi devo recuperare un po' di terreno per poter fare il tuo calcolo matriciale in meno di 2 sec... ma tempo al tempo...
Originariamente inviato da a2000
[B]sì anche quello.
ci credi sulla parola o vuoi vedere quello che voi Cplusplani non potete neanche immaginare ...
Non mi interessano i giochini su Excel...
Non è che potresti farmi vedere l'algoritmo con l'estrazione della matrice 10x10 in uno pseudo-linguaggio così implementiamo lo stesso algoritmo e vediamo quale compilatore è più veloce...
Se è una questione di ottimizzazione di algoritmi tutto quello che si può fare in Fortran si può fare in C++...
KRYHAWOK
15-02-2002, 13:23
Originariamente inviato da cionci
[B]
Se è una questione di ottimizzazione di algoritmi tutto quello che si può fare in Fortran si può fare in C++...
Penso che sia proprio questo il punto fondamentale su cui non riusciamo a farci capire da a2000.
Se, come a2000 sostiene, la velocità del Fortran sta nel fatto che il compilatore esegue le operazioni in modo più efficiente del C++, basta scrivere codice C++ migliore, ma questo mi pareva ovvio... ed è in questo che io trovo l'inutilità del Fortran oggi: C++ ha strumenti più potenti in molti campi rispetto al F. e i "suoi difetti" possono essere risolti semplicemente con una accorta impostazione del codice.
I punti sono due:
1) a parità di algoritmo il Fortran è più veloce:
per toglierti il dubbio, cionci, confronta il tempo del NAIVE del C++, che mi pare avevi dichiarato essere intorno ai 100 s, con il tempo del NAIVE Fortran che è pari a circa 41.6 * 1400/1000 = 58.24 s con il tuo Tb1000 (cambialo che è ora, anzi no: mettilo in cluster).
e per aggiunta:
2) chi scrive in Fortran scrive algoritmi più veloci.
chi scrive in Fortran ha almeno una (1) laurea di tipo tecnico/scientifico, ha in genere un background di Analisi Matematica, Calcolo Numerico, Teoria dei Sistemi, Modellazione matematica (una su tutte: fuidodinamica numerica), per cui
utilizza, conosce, ha studiato, sa dove trovare algoritmi di calcolo numerico che vanno dai piccoli ma fondamentali accorgimenti di uso efficiente della potenza di calcolo, della memoria dati, e (una volta) anche della memoria di codice, alla FFT.
Scusa, cionci, ma quanti ce ne sono di Cplusplani che se gli dici di fare la somma dei numeri da 1 a n, ti fanno un ciclo For ... Next ?
E quanti codici "brute-force" si vedono perchè non si è mai aperto un libro di matematica, di calcolo numerico, ma neppure la settimana enigmistica, con grande gioia di Intel e AMD.
Ma non c'è niente da dire, programmano sì, ma fanno un altro mestiere, come dire: sono degli "istintivi", dei "volenterosi", dei "come natura crea" ...
Dopo, che qualche eccentrico della famiglia (della "nostra" famiglia) si metta a programmare algoritmi di risoluzione di sistemi di equazioni differenziali alle derivate parziali in C++, alla maniera del Fortran, traducendoli dalle routine di "Fortran Recipes" può succedere, va bene, aumenta la biodiversità.
Cioè, cosa vi devo dire:
chi è che scrive in Fortran ?
e che cosa si scrive in Fortran ?
Ragazzi, sia il Fortran in se stesso ma soprattutto quello che si scrive in Fortran è roba di lusso, non è per tutti ...
Ci sono le automobili e c'è il (sì, sì: "il") Mercedes,
Poi, certo, per portare l'insalata dell'orto nei campi è meglio la Duna SW.
Come disse un illustre professore universitario ad un tecnico di laboratorio che, giustamente, per carità, gli chiedeva ragguagli, dopo tre mesi (poveretto), sul suo primo stipendio:
"Cosa vuole, caro, qui siamo tutti signori".
Comunque non vi fissate, tranquilli, vi ho già citato il compagno che diceva:
"La storia è una cosa molto lunga, .... ma anche molto larga":
c'è posto per tutti.
Come vedete vi servo in modo ecumenico: di destra e di sinistra.
!************************************************
Ma a parte tutto, vi piace stò thread o no ?
Ca++o, URLOFEROCE, ma per un successone così, mi dovresti riconoscere una % in PVT.
Ah, non ti interessano i giochini in Excel ?
Dopo bisognerebbe aprire un'altra discussione sull'effetto devastante, il tempo perso, gli accrocchi immondi, i SOLDI RUBATI, quanti soldi rubati ...., (da denuncia, +++ buono!),
generati dalle interfacce grafiche in VisualBasic, quando c'è, invece di tutti i cazzibuffi di buttons, text-box, list-box ecc. ecc., un super-controllo che se li mangia tutti alla stragrande: Worksheets.
Volete riutilizzare le classi ?
Usate quelle cazzute di Excel-VBA !
(tra cui, modestamente, vi consiglio "Collection")
P.S.
VisualBasic, in realtà, è un Fortran (dei poveri, ma è un Fortran).
Ca++o, siete circondati !
Originariamente inviato da a2000
[B]1) a parità di algoritmo il Fortran è più veloce:
per toglierti il dubbio, cionci, confronta il tempo del NAIVE del C++, che mi pare avevi dichiarato essere intorno ai 100 s, con il tempo del NAIVE Fortran che è pari a circa 41.6 * 1400/1000 = 58.24 s con il tuo Tb1000 (cambialo che è ora, anzi no: mettilo in cluster).
Ottengo 70 secondi circa...mi ero scordato di settare la versione release...la versione debug è molto + lenta...
Ma è chiaro che la versione base è più lenta...il C++ non ha una gestione ottimizzata per le matrici... Quello che sto dicendo che usando algoritmi fortemente ottimizzati la differenza è minima...è per quello che volevo provare con l'algoritmo che estre le matrici 10x10...
Comunque la mia versione migliore è limitata dalla bandwidth della memoria...infatti overclockando il mio Tbird da 1000 a 1333 il risultatato cambia di soli 2 decimi di secondo!!!
Tu hai un sistema come memoria DDR ?
Originariamente inviato da a2000
[B]2) chi scrive in Fortran scrive algoritmi più veloci.
chi scrive in Fortran ha almeno una (1) laurea di tipo tecnico/scientifico, ha in genere un background di Analisi Matematica, Calcolo Numerico, Teoria dei Sistemi, Modellazione matematica (una su tutte: fuidodinamica numerica), per cui
utilizza, conosce, ha studiato, sa dove trovare algoritmi di calcolo numerico che vanno dai piccoli ma fondamentali accorgimenti di uso efficiente della potenza di calcolo, della memoria dati, e (una volta) anche della memoria di codice, alla FFT.
Su questo siamo d'accordo, anche se ho visto laureandi in Fisica fare la tesi in C...
Originariamente inviato da a2000
[B]Scusa, cionci, ma quanti ce ne sono di Cplusplani che se gli dici di fare la somma dei numeri da 1 a n, ti fanno un ciclo For ... Next ?
E quanti codici "brute-force" si vedono perchè non si è mai aperto un libro di matematica, di calcolo numerico, ma neppure la settimana enigmistica, con grande gioia di Intel e AMD.
Io no e come me tutti quelli che usano C o C++ e studiano ingegneria informatica o scienze dell'informazione...
Comunque (n*(n+1))/2 ;)
Originariamente inviato da a2000
[B]Dopo, che qualche eccentrico della famiglia (della "nostra" famiglia) si metta a programmare algoritmi di risoluzione di sistemi di equazioni differenziali alle derivate parziali in C++, alla maniera del Fortran, traducendoli dalle routine di "Fortran Recipes" può succedere, va bene, aumenta la biodiversità.
Quello che sto tendando di dire è che è tutta una questione di librerie (ad esempio utilizzando librerie il cui codice è già compilato in Fortran)...
Originariamente inviato da a2000
[B]
Ma a parte tutto, vi piace stò thread o no ?
Ca++o, URLOFEROCE, ma per un successone così, mi dovresti riconoscere una % in PVT.
Cavolo se mi piace, altrimenti non ci posterei !!!! :D :D
Originariamente inviato da a2000
[B]VisualBasic, in realtà, è un Fortran
Questa è una affermazione un po' pesina...in che senso ?
KRYHAWOK
15-02-2002, 18:33
Originariamente inviato da a2000
[B]I punti sono due:
1) a parità di algoritmo il Fortran è più veloce:
per toglierti il dubbio, cionci, confronta il tempo del NAIVE del C++, che mi pare avevi dichiarato essere intorno ai 100 s, con il tempo del NAIVE Fortran che è pari a circa 41.6 * 1400/1000 = 58.24 s con il tuo Tb1000 (cambialo che è ora, anzi no: mettilo in cluster).
e per aggiunta:
2) chi scrive in Fortran scrive algoritmi più veloci.
chi scrive in Fortran ha almeno una (1) laurea di tipo tecnico/scientifico, ha in genere un background di Analisi Matematica, Calcolo Numerico, Teoria dei Sistemi, Modellazione matematica (una su tutte: fuidodinamica numerica), per cui
utilizza, conosce, ha studiato, sa dove trovare algoritmi di calcolo numerico che vanno dai piccoli ma fondamentali accorgimenti di uso efficiente della potenza di calcolo, della memoria dati, e (una volta) anche della memoria di codice, alla FFT.
Scusa, cionci, ma quanti ce ne sono di Cplusplani che se gli dici di fare la somma dei numeri da 1 a n, ti fanno un ciclo For ... Next ?
E quanti codici "brute-force" si vedono perchè non si è mai aperto un libro di matematica, di calcolo numerico, ma neppure la settimana enigmistica, con grande gioia di Intel e AMD.
Ma non c'è niente da dire, programmano sì, ma fanno un altro mestiere, come dire: sono degli "istintivi", dei "volenterosi", dei "come natura crea" ...
Dopo, che qualche eccentrico della famiglia (della "nostra" famiglia) si metta a programmare algoritmi di risoluzione di sistemi di equazioni differenziali alle derivate parziali in C++, alla maniera del Fortran, traducendoli dalle routine di "Fortran Recipes" può succedere, va bene, aumenta la biodiversità.
Cioè, cosa vi devo dire:
chi è che scrive in Fortran ?
e che cosa si scrive in Fortran ?
Ragazzi, sia il Fortran in se stesso ma soprattutto quello che si scrive in Fortran è roba di lusso, non è per tutti ...
Ci sono le automobili e c'è il (sì, sì: "il") Mercedes,
Poi, certo, per portare l'insalata dell'orto nei campi è meglio la Duna SW.
Come disse un illustre professore universitario ad un tecnico di laboratorio che, giustamente, per carità, gli chiedeva ragguagli, dopo tre mesi (poveretto), sul suo primo stipendio:
"Cosa vuole, caro, qui siamo tutti signori".
Comunque non vi fissate, tranquilli, vi ho già citato il compagno che diceva:
"La storia è una cosa molto lunga, .... ma anche molto larga":
c'è posto per tutti.
Come vedete vi servo in modo ecumenico: di destra e di sinistra.
!************************************************
Ma a parte tutto, vi piace stò thread o no ?
Ca++o, URLOFEROCE, ma per un successone così, mi dovresti riconoscere una % in PVT.
Quante dozzine di lauree hai allora?
PS: se fai la brava mamma, magari ti permetterò di aprire un thread "Ma quanto sono inutili le classi in C++?".. così magari puoi dormire la sera..
vi rispondo dopo, adesso devo andare a fare con Lorenzo il Mondo di Nasty.
Ma si può usare un forum come una chat ?
KRYHAWOK
16-02-2002, 18:15
Originariamente inviato da a2000
[B]vi rispondo dopo, adesso devo andare a fare con Lorenzo il Mondo di Nasty.
Ma si può usare un forum come una chat ?
Vabe' .. dai... mi pare che cmq qualcosa di produttivo siamo riusciti a tirarlo fuori da sto thread.;)
Beh, sicuramente avrete migliorato la vostra conoscenza dei linguaggi: il Fortran ma, soprattutto, ... l' Italiano !
altri due problemini di 'calcolo delle somme' per cionci:
somma dei quadrati dei numeri interi da 1 a N e in generale somma delle potenze intere;
e, da sapere a memoria:
somma dei primi n numeri dispari
problemino per URLOFEROCE:
se la mamma deve comprare 12 uova ....
no scherzo!
allora ... in un codice di calcolo le due espressioni:
1 + v*(K-1) v € [0, 1]
1 + v*K - v
sono equivalenti? e se no quale è preferibile adottare ?
Per la somma dei dispari...è ovviamente n^2...per l'altra ammetto la mia ignoranza...anche se avendo un po' di voglia potrei provare a trovarla...
Comunque a me interessava conoscere l'algoritmo per il prodotto righe-colonne che hai usato per ottenere 2 secondi...me lo scrivi te o mi devo mettere a tradurre dal Fortran che non conosco ?
Originariamente inviato da a2000
1) a parità di algoritmo il Fortran è più veloce:
Quasi quasi provo anche Python + Numeric, se ne ho voglia :)
A scanso equivoci: matrice 1000 x 1000 di numeri casuali, ok?
(cambialo che è ora, anzi no: mettilo in cluster).
MOSIX o Beowulf?
2) chi scrive in Fortran scrive algoritmi più veloci.
Orpola', per contratto? Altrimenti il listato si rifiuta di compilarsi? :D
Ma a parte tutto, vi piace stò thread o no ?
Si'. Mi ha rimesso voglia di studiarmi il libro di algoritmi.
Non che prima non ne avessi, ma disperavo di farlo incastrare tra gli studi "regolari"
Originariamente inviato da Ikitt
Quasi quasi provo anche Python + Numeric, se ne ho voglia :)
A scanso equivoci: matrice 1000 x 1000 di numeri casuali, ok?
[ Session start ]
Python 2.1.1 (#20, Jul 20 2001, 01:19:29) [MSC 32 bit (Intel)] on win32
Type "copyright", "credits" or "license" for more information.
IDLE 0.8 -- press F1 for help
>>> from Numeric import *
>>> data = array(arrayrange(1000000.0), Float64)
>>> data2 = reshape(data, (1000,1000))
>>> data2.shape
(1000, 1000)
>>> import time
>>> def bench():
start = time.time()
temp = data2 * data2
stop = time.time()
print "Elaboration time: ", stop-start, " seconds"
>>> bench()
Elaboration time: 0.110000014305 seconds
>>>
[ Session stop ]
Non malaccio per un test preliminare :)
Mmmhh...mi sembra troppo poco...forse perchè hai moltiplicato la matrice per se stessa...
Originariamente inviato da Ikitt
Non malaccio per un test preliminare :)
Ed ora il test vero e proprio:
[session start]
Python 2.1.1 (#20, Jul 20 2001, 01:19:29) [MSC 32 bit (Intel)] on win32
Type "copyright", "credits" or "license" for more information.
IDLE 0.8 -- press F1 for help
>>> import time
>>> from Numeric import *
>>> temp = array(arrayrange(1000000),Float64)
>>> data1 = reshape(temp,(1000,-1))
>>> temp = array(arrayrange(5,1000005),Float64)
>>> data2 = reshape(temp, (1000,-1))
>>> data1.shape, data2.shape
((1000, 1000), (1000, 1000))
>>> def bench():
start = time.time()
t = matrixmultiply(data1,data2)
stop = time.time()
print "Elaboration time: ", stop-start, " seconds"
>>> bench()
Elaboration time: 36.3099999428 seconds
>>>
[session stop]
Assolutamente degno di nota, direi :) (Python e' un linguaggio _interpretato_ e di altissimo livello):
solo 10 volte (circa) piu' lento del migliore della categoria, non mi sembra affatto malaccio.
Ovviamente, questo e' un'algoritmo totalmente bruteforce, usandone uno un po' migliore credo sarebbe possibile arrivare a ridosso dei 10-15 secondi, risultato che mi sembrerebbe di notevole rilievo :)
La distanza di un'ordine di grandezza rispetto al test precedente e' che, inaspettatamente (per me), l'operatore * applicato agli array NON effettua il prodotto righe per colonne, mentre lo fa matrixmultiply()
E con questo ho finito :)
Comunque renditi conto che l'algoritmo lì è già scritto...e sicuramente sarà il più performante possibile per l'interprete Python...
Originariamente inviato da cionci
Comunque renditi conto che l'algoritmo lì è già scritto...
Certamente! Ma conoscendo bene come opera e' possibile fornirgli l'input "giusto" risparmiando qualche secondo.
Oppure, volendo, lo si potrebbe addirittura riscrivere... ;)
e sicuramente sarà il più performante possibile per l'interprete Python...
Molto probabile, anzi quasi certo.
Comunque non voglio entrare nella competizione e non intendo continuare ulteriormente il test...
Ripeto, pero' che mi sembra un risultato di tutto riguardo: un tempo quasi uguale alla tua seconda versione in C++, per di piu' da un linguaggio interpretato e senza perderci neppure tanto tempo ;)
Nota: Ho un XP 1500+
Già che hai un XP 1500+, hai anche una scheda madre con le DDR ? Proveresti il mio programma, perchè mi sembra che il mio algoritmo sia bandwidth limited...io con le SDR passando da 1000 a 1333 faccio sempre lo stesso tempo ;)
Non lo posso allegare la post perchè è circa 45 Kb...se mi mandi una e-mail te lo invio attaccato alla risposta...
Originariamente inviato da cionci
Già che hai un XP 1500+, hai anche una scheda madre con le DDR ?
Yep. 256 MB DDR266 CAS 2.5, pero'.
Proveresti il mio programma, perchè mi sembra che il mio algoritmo sia bandwidth limited...io con le SDR passando da 1000 a 1333 faccio sempre lo stesso tempo ;)
Lo provo volentieri, ma posso compilarlo solo e soltanto sotto Linux (g++ 2.95.3) dato che per Win non ho il compilatore.
Non lo posso allegare la post perchè è circa 45 Kb...se mi mandi una e-mail te lo invio attaccato alla risposta...
Ok, appena posso ti emailo.
KRYHAWOK
18-02-2002, 23:31
Originariamente inviato da a2000
[B]
1 + v*(K-1) v € [0, 1]
1 + v*K - v
sono equivalenti? e se no quale è preferibile adottare ?
Se ho capito bene: K è costante arbitraria, mentre V varia nell'intervallo [0, 1], giusto? Non so se tu intendi che V sia razionale (e con quale incremento in questo caso) o intera (in questo caso assume solo V=0 e V=1)... ma pazienza. Mi chiedi quale sia il codice che viene eseguito più velocemente?
Dunque, comincio a lavarmi un po' le mani supponendo che non ci siano variazioni di rapidità di esecuzione a seconda dell'insieme numerico a cui appartengono K e V. Cmq, mi sono venute in mente due differenze principali che il compilatore si troverebbe davanti nei due casi:
1) Il tipo di parser utilizzato - la prima espressione deve essere valutata dal compilatore tenendo conto delle parentesi presenti. Dato che sia l'espressione 1 che la 2 richiedono entrambe tre calcoli numerici per essere compiute, la prima ha "a suo sfavore" il fatto che, contenedo una coppia di parentesi, sia più lunga da valutare da parte del parser.
2) La velocità di accesso alla memoria - nell'espressione 2 compare due volte la variabile V, e quindi la CPU deve sbattersi a recuperare per due volte il valore assunto da V nel calcolo globale. Questo invece non accade nell'espressione 1 dove V è presente un'unica volta.
Non conoscendo nello specifico i tipi diversi di parser nè tantomeno come viene gestita nel dettaglio l'accesso alla memoria da parte dei vari linguaggi, non saprei dirti se il punto 1 la spunta sul punto 2 o viceversa. Sono sulla buona strada, mamma?
PS: non mi hai risposto: quante lauree hai (per riuscire a "usare" il Fortran..)?
Originariamente inviato da Ikitt
Lo provo volentieri
Ho fatto un test preliminare: esami piu` approfonditi
a quando avro` ancora tempo...
Allora, prima di tutto ho cambiato queste righe per far compilare il tutto:
in main():
#include "matrice.h"
#include <cstdlib>
#include <iostream>
#include <ctime>
[...]
time_t start = time(0);
m3 = m*m2;
time_t stop = time(0);
cout << double(difftime(stop,start)) << endl;
nell'header file della classe matrice:
#include <cstring>
#include <cstdlib>
[...]
matrice<TIPO>::matrice(int righe, int colonne)
// CUT
#ifdef ZFILL
ZeroMemory(m,sizeof(TIPO)*r*c);
#endif //ZFILL
// CUT
+++
Piattaforma di test:
115$ france@samurai2 c++>1 g++ -O3 -mcpu=i686 -ffast-math -fexpensive-optimizations -o ./bench ./bench.cpp
116$ france@samurai2 c++>1 time ./bench
16
real 0m15.572s
user 0m15.500s
sys 0m0.070s
13$ france@samurai2 c++>3 ldd ./bench
libstdc++-libc6.2-2.so.3 => /usr/lib/libstdc++-libc6.2-2.so.3 (0x4001e000)
libm.so.6 => /lib/i686/libm.so.6 (0x40061000)
libc.so.6 => /lib/i686/libc.so.6 (0x40084000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
14$ france@samurai2 c++>3 g++ --version
2.95.3
121$ france@samurai2 c++>1 uname -a
Linux samurai2 2.4.17 #2 ven dic 21 20:52:16 CET 2001 i686 unknown
122$ france@samurai2 c++>1 cat /proc/cpuinfo
processor : 0
vendor_id : AuthenticAMD
cpu family : 6
model : 6
model name : AMD Athlon(tm) XP 1500+
stepping : 2
cpu MHz : 1334.975
cache size : 256 KB
fdiv_bug : no
hlt_bug : no
f00f_bug : no
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 1
wp : yes
flags : fpu vme de pse tsc msr pae mce cx8 sep mtrr pge mca cmov pat
pse36 mmx fxsr sse syscall mmxext 3dnowext 3dnow
bogomips : 2660.76
+++
Mi sembra strano che impieghi lo stesso tempo o quasi sia nel ciclo piu` interno
che nell'inizializzazione...
Per il resto, per fare un calcolo piu` preciso del tempo speso nel ciclo piu`
interno, ho trovato la syscall adatta ma devo studiarne il funzionamento (mai
usata una qualsivoglia syscall prima d'ora :) )
Continuo a non capire l'utilita` di riempire la memoria della matrice di zeri
all'inizializzazione, ma nel test l'ho compilata senza solo perche` non ho
trovato un adeguato rimpiazzo...
Originariamente inviato da Ikitt
[B]Originariamente inviato da Ikitt
Continuo a non capire l'utilita` di riempire la memoria della matrice di zeri
all'inizializzazione, ma nel test l'ho compilata senza solo perche` non ho
trovato un adeguato rimpiazzo...
L'ho riempita di zero per avere la matrice ad un valore consistente anche ad un primo utilizzo...
In effetti, ora che ci penso, dopo l'ultima modifica che ho fatto (usando una variabile temporanea in cui mettere il risultato parziale del prodotto) non è più necessario riempirla di zero...
In ogni caso ho fatto una misurazione all'inizio e alla fine del ciclo ed ottengo solo 3 decimi di secondo in meno rispetto a farla su tutta l'operazione m3 = m*m2...
Stai tranquillo ne utilizzerai molte in prossimo futuro di syscall ;)
Non vi ho abbandonato.
Sono solo impegnato nello start-up di un'interfaccia multipurpose ad oggetti grafici per tutti quei sistemi che possono essere rappresentati con un grafo, per esempio schemi di processo per impianti chimici, reti di trasporto fluidi, circuiti elettrici a parametri concentrati, ecc.
La cosa deve essere friendly, code-free, light, drag & drop e ginfizz.
Interessa ?
URLOFEROCE TI CURO: vado per la 2a inge ed il 3o figlio.
KRYHAWOK
19-02-2002, 16:30
Originariamente inviato da a2000
[B]
URLOFEROCE TI CURO: vado per la 2a inge ed il 3o figlio.
Ehilà.... si può dire che sai come occupare il tempo libero! Spero di far parte anch'io della combriccola fra 4 anni... e domani il temutissimo esito dell'esame di informatica A...
A parte questo, che mi dici di quel che ho scritto riguardo alle due formule che avevi proposto prima?
Byez.
Originariamente inviato da a2000
La cosa deve essere friendly,
Brutta bestia...
code-free
E allora come fa a funzionare? :D:D:D
light
Conosci FLTK per X11R6?
Interessa ?
Un po' la parte sui grafi.
vado per la 2a inge ed il 3o figlio.
Ognuno il tempo lo impegna come vuole... :D
Originariamente inviato da Ikitt
E con questo ho finito :)
Le ultime parole famose! :D
Ma insisto perche' un guadagno di 8 secondi cosi', a gratis,
credo sia notevole:
[session start]
Python 2.1.1 (#20, Jul 20 2001, 01:19:29) [MSC 32 bit (Intel)] on win32
Type "copyright", "credits" or "license" for more information.
IDLE 0.8 -- press F1 for help
>>> from Numeric import *
>>> from Matrix import *
>>> import time
>>> m1 = Matrix(reshape(arrayrange(1000000),(1000,-1)))
>>> m2 = Matrix(reshape(arrayrange(1000000),(1000,-1)))
>>> m1 is m2
0
>>> def bench():
start = time.time()
t = m1 * m2
stop = time.time()
print "Elaboration time: ", stop-start, "seconds"
>>> m1.shape, m2.shape
((1000, 1000), (1000, 1000))
>>> bench()
Elaboration time: 27.8500000238 seconds
>>>
[session stop]
A questo punto credo proprio che studiandosi per bene il modulo Numeric il traguardo dei 15 secondi non sia cosi' improbabile...
Ma stavolta la chiudo qua per davvero, Python per quanto mi riguarda ha gia' dato abbastanza ;)
il traguardo è a 2.34 s su Tb1400.
Comunque tempi dell'ordine del 540% in più con linguaggi-compilatori non orientati al calcolo numerico (che è l'unica cosa che conta) sono soddisfacenti ... dalle rape non si tira fuori il sangue.
Tra l'altro il vecchio qb45 seminterpetrato aveva tempi di esecuzione dell'ordine del 2000% in più.
sforzatevi ancora. non troppo però ...
Originariamente inviato da a2000
il traguardo è a 2.34 s su Tb1400.
Nope, il traguardo sono tempi attorno ai 10 secondi ;)
Comunque tempi dell'ordine del 540% in più con linguaggi-compilatori non orientati al calcolo numerico (che è l'unica cosa che conta) sono soddisfacenti ... dalle rape non si tira fuori il sangue.
Uh, la versione Python (ripeto: linguaggio INTERPRETATO[1] e di altissimo livello) e' solo 12 volte circa piu' lento :D:D:D
Un'altro punto per il rettilone :)
[1] Anche semicompliato volendo, ma nei miei test non l'ho fatto e non credo che il guadagno sia degno di nota...
sforzatevi ancora. non troppo però ...
Ti dicessi quanto mi sono sforzato sinora, forse ci rimarresti un po' male (il calcolo numerico NON e' il mio campo ;) )
chi è Nope, l'amico di Amalgama ?
comunque vai tranquillo che il traguardo è molto sotto i 5 s (per noi).
a2000 : mi dai l'algoritmo in pseudocodice con il quale ottieni 2 seconid ? Grazie ;)
Originariamente inviato da a2000
chi è Nope, l'amico di Amalgama ?
Nope == No Hope
comunque vai tranquillo che il traguardo è molto sotto i 5 s (per noi).
Per voi, appunto. Io, che appunto non mi interesso (ora e nell'immediato futuro) di calcolo numerico intensivo, mi accontento di assai meno. ;)
Originariamente inviato da a2000
[B]no
Grazie...
Comunque, da quello che ho visto il tuo algoritmo non funziona per matrici con dimensione maggiore di 10...o sbaglio ?
scusa, questi forum impongono tempi e battute teatrali.
ogni cosa a suo tempo. comunque fidati.
Lo pseudocodice ...
ca++o, il Fortran praticamente è uno pseudocodice, cosa ti devo dire, sostituisci
'Do i=1, 100, 10' con
'Per i da 1 a 100, passo 10, esegui' oppure 'For i=1 To 100 Step 10'
poi cosa c'è ... istruzioni di assegnazione, istruzioni di controllo 'If Then Else' e quelle sono autoexplaining
ah, l'estrazione di sottomatrici: niente, per estrazioni contigue la sintassi è intuitiva, per esempio:
aa(1:KK) = a(i, 1:KK)
estrae gli elementi da 1 a KK della riga i-esima della matrice a e li assegna agli elementi da 1 a KK del vettore aa.
Cioè, mi fai il difficile con il Fortran che praticamente è il cugino ricco del Basic, quando il C++ ha una sintassi a geroglifici ... dai su.
Per dirti, se faccio un copia incolla da Fortran90 a VisualBasic, TAL QUALE, con tre giri di debugging sintattico ho fatto la conversione. Viceversa è un pò più tosto.
Conviene passare da Word [faccina che ride].
Comunque ribadisco...come fa il tuo algoritmo a funzionare su una matrice di 3 elementi ?
e aspetta un attimo le risposte, non è mica una chat.
e dagli co stè 10 colonne, te l'ho già detto funziona in generale per matrici da 1, 17, 345, 7896 righe e colonne ( il numero delle colonne della prima uguale al numero di righe della seconda e bla bla bla bla bla bla "Aladino, StarDust 1998").
Ho capito che l'algoritmo è generale...ma come fai a scriverlo in modo che dati due parametri di cui non puoi conoscere il valore a priori che sono (semplifichiamo a matrici quadrate) righe e colonne ?
lo sapevo, devo spezzare le risposte come nella traduzione simultanea.
Scusa ma se ho 438 righe per esempio, le spezzo in 43 blocchi da 10, 1 blocco da 5, 1 blocco da 2, 1 'blocco' da 1
(10, 5, 2, 1 sono SOLO di esempio)
si chiama numerazione a base mista:
baseM = [10, 5, 2, 1]
432 base 10 = 43,1,1,1 baseM
lo stesso per le colonne, e poi moltiplico e sommo termine a termine i vettori estratti. e vai a busso !
Cioè fai una prova, poi la generalizzazione in questo caso, è solo una piccola complicazione (per chi non si è fissato solo con i numeri binari e decimali e esadecimali)
Cioè date le due matrici a(1:II, 1:KK) e b(1:KK, 1:JJ)
spezzo la matrice a
in b10 = Int(II/10) blocchi da 10 righe,
in b5 = Int ((II - 10*b10)/5) blocchi da 5 righe,
in b2 = Int ((II - 10*b10 - 5*b5)/2) blocchi da 2 righe,
in b1 = Int ((II - 10*b10 - 5*b5 - 2*b2)/1) 'blocchi' da 1 righe,
lo stesso per la matrice b con le colonne
e poi faccio il prodotto righe per colonne delle cosiddette matrici a blocchi.
insomma l'algoritmo di base è ridotto alla somma dei prodotti termine a termine di due vettori.
ed è lì che secondo me potresti fare meglio col C.
fai questa routine ottimizzata, il resto viene da se.
Ok...ci provo...intanto voglio provare quanto viene veloce...
poi è chiaro che qualcosa si paga.
in questo caso righe di codice.
poi la sai la legge (più regola fuzzy veramente) che dice
TempoCalcolo + Memoria + TempoProgrammazione + RigheCodice = cost(funzione del programmatore)
Cioè, per esempio, TU (cost) vuoi un codice veloce ?
allora usa più memoria, più righe di codice, più tempo di programmazione.
Ohm, Ohm, Ohm ... (non quello di V=RI)
sempre della serie + Memoria - TempoCalcolo
un problema vero è nell'allocazione dinamica degli array, ed è per questo che a volte si preferisce l'allocazione statica di array sovradimensionati (velocità) a quella dinamica di array 'giusti' (uso efficiente di memoria)
Questo in Fortran.
Poi il mio amico Cplusplano convinto e anche il manuale di VB dicono che, rispettivamente, l'uso dei template e delle variabili variant non appesantiscono molto il calcolo ...
ma non ci credo molto
Ca++o, con variabili variant tipo v(2)(3,4)(5,6,7)
cioè vettori di matrici di matrici non mi pare ...
Ma quanti Mangiatori di Fortran !
Comunque va bene, l'importante è che entri da qualche parte.
il Fortran.
devo ricorrere ad un pò di aliasing ...
Ad una prima implementazione...sono a 5,7 secondi...ora parto con l'ottimizzazione...
così mi piaci ...
cioè ... non ottimizzare troppo senno non ci passa più.
Vabbè...ora chiudo tutto e ci riprovo domani...
Ciao :)
KRYHAWOK com'è andato l'esame ?
Bene spero, visto che ci hai fatto fare un culo così per il tuo sondaggio del C++.
Per la domanda sulla formula, hai ragione, .... ma non sempre, caro, i maestri conoscono le risposte alle domande che fanno.(tienilo conto quando fai gli esami)
No, comunque, era un problema di cifre significative sorto in una routine per la soluzione di stadi di equilibrio a due fasi con reazioni chimiche (flash reattivi).
mej cojoni.
nocino, quantaltro e
buonanotte.
KRYHAWOK
21-02-2002, 00:09
Originariamente inviato da a2000
[B]KRYHAWOK com'è andato l'esame ?
Bene spero, visto che ci hai fatto fare un culo così per il tuo sondaggio del C++.
Per la domanda sulla formula, hai ragione, .... ma non sempre, caro, i maestri conoscono le risposte alle domande che fanno.(tienilo conto quando fai gli esami)
No, comunque, era un problema di cifre significative sorto in una routine per la soluzione di stadi di equilibrio a due fasi con reazioni chimiche (flash reattivi).
Quella troja mi ha fatto andare a Milano per un ##zzo! Esito dell'esame rinviato al 27 febbraio.... la gente che non ha rispetto per il tempo degli altri...
Quindi il "maestro" non conosce la risposta alla domanda che mi ha fatto.?.?.. vabe'.. visto il contributo al thread (che comincia a trascendere le mie limitate conoscenze di programmazione... ma non ditelo troppo in giro), ti perdono per questa volta.
Scherzi a parte, mi piacerebbe sul serio fare qualche passo avanti nella programmazione, visto che quello che ho dato è l'unico e ultimo esame di informatica che farò a ingegneria... Dato che mi avete cazziato lo Shildt, che libro mi consigliate che parta da un livello superiore a quello "base", ovvero che tratti anche di ottimizzazione di codice et similia?
PS: facendo girare le due formule nel caso pratico in cui le hai applicate, qual'era la più rapida?
no, non è una questione di velocità, era una questione di cifre significative (o di mach_eps, se ti compri il libro sotto) per cui se (ma non è così, non ricordo bene, sai la vecchiaia) K=1e25 si mangia l'uno in parentesi e sballa il calcolo.
E' lo stesso problema di quando si valutano i polinomi a segni alterni con termini molto grandi.
Ma schiusa se studi al 'Poli', informati su chi è Buzzi-Ferraris.
da www.addison.it/html/libri/31.htm :
"
METODI NUMERICI E SOFTWARE IN C++
Guido Buzzi-Ferraris
770 pp con CD-ROM
Lit. 80.000
ISBN:
88-7192-063-5
In questo libro vengono trattati problemi di analisi numerica e descritte le corrispondenti classi in C++ che permettono di risolverli.
Ciascun problema è svolto, nei limiti del possibile, separatamente, in modo da consentire al lettore la consultazione di ogni argomento indipendentemente dagli altri.
Il linguaggio C++ e' stato scelto rispetto al FORTRAN perche', oltre ad essere un linguaggio di programmazione ad oggetti e non di tipo procedurale, offre una maggiore facilita' d'uso ed efficienza dei codici prodotti.
Il libro e' indirizzato sia a un mercato accademico, per i corsi di analisi numerica e di programmazione, che a quello professionale, per tutti coloro che devono risolvere numericamente problemi di tipo scientifico. Nel CD-ROM allegato viene fornita una libreria di circa 95 classi distinte, che permettono di risolvere in C++ i problemi trattati nel corso del libro.
Tali librerie possono essere utili nei corsi di programmazione in C++ per imparare a risolvere problemi numerici anche complessi.
L'autore
Guido Buzzi-Ferraris e' professore ordinario di Analisi dei Sistemi nell'Ingegneria Chimica al Politecnico di Milano ed e' autore di piu' di cento articoli, pubblicati su riviste a diffusione internazionale, inerenti a problemi di carattere numerico.
E' autore per Addison-Wesley del libro Dal FORTRAN AL C++, tradotto e pubblicato, sempre da Addison-Wesley, con il titolo Scientific C++, e diventato un testo classico per la programmazione in C++ in campo scientifico. "
KRYHAWOK
21-02-2002, 18:56
Ok, grazie per il consiglio; spero che analisi B mi lasci sopravvivere (......per dedicarmi un po' anche a informatica....).
Già che ci sono, hai mai provato ad entrare nel mondo delle OpenGL?
pjtaddei
21-02-2002, 20:11
KRYHAWOK : esame con la Morpurgo?
no con la Fortrani.
(classe 1925)
KRYHAWOK
21-02-2002, 22:14
Originariamente inviato da pjtaddei
[B]KRYHAWOK : esame con la Morpurgo?
Sardi / Garzotto
MickMacello
02-04-2002, 23:50
Originariamente inviato da a2000
[B]il traguardo è a 2.34 s su Tb1400.
5.4 secondi su P3 800@992.
non male considerando che il tbird ha una FPU più efficiente.
Ho usato pari pari l' algoritmo di a2000, traducendolo in C/C++.
Stuzzicato dal vostro dibattito ho provato il seguente script sul mio caro Matlab:
clear all;
a = rand(1000,1000);
b = rand(1000,1000);
whos
tic;
c = a*b;
toc;
Ottengo tempi inferiori a 4 secondi (3.86 , 3.81...)
Ho un misero athlon 500 con 128 mega di ram affaticato da ore di lavoro .. il fortran sara' buono ma Matlab e' eccellente (non per niente matrix lab) :)
ciao
Dimenticavo..
Matlab e' programmato in Java. (l'interfaccia utente)
riciao
MickMacello : io sono a 3.2 s con un Tbird 1333...con l'algoritmo di a2000 ottimizzato da me...ma già a 1000 Mhz sono a 3.8 s, quindi il mio algoritmo è bandwidth limited, come probabilmente il tuo...
someday : il fatto di ottenere tempi inferiori a 4 secondi è un po' strano... Quante sono le operazioni fatte in una moltiplicazione 1000 x 1000 ? Ogni elemento della matrice di sinistra viene moltiplicato per ogni elemento della corrispondente riga della matrice di destra...quindi 1000 volte...per un milione di elementi...sono un milione di moltiplicazioni... Per ogni moltiplicazione devo sommare al risultato già trovato precedentemente...quindi sono un altro milione di somme...
Un totale di 2 milioni di operazioni... Se le cose andassero sempre bene (ovvero se la CPU sfornasse una operazione FPU per ciclo di clock) allora a 500 Mhz avresti il limite inferiore teorico di 4 secondi...
Quindi le cose sono 2...o Matlab usa le 3dNow (quindi non vale ;)) o ha qualche ottimizzazione sui valori (seppur casuali) degli operatori (ad esempio potrebbe essersi calcolato durante la creazione della secondo matrice parte della somma, visto che è una delle operazioni + comuni)...
Mi fai un piacere ? Savati le operazioni in un file e prova a prendere il tempo già dalla creazione delle due matrici...
Originariamente inviato da someday
[B]Stuzzicato dal vostro dibattito ho provato il seguente script sul mio caro Matlab:
clear all;
a = rand(1000,1000);
b = rand(1000,1000);
whos
tic;
c = a*b;
toc;
Ottengo tempi inferiori a 4 secondi (3.86 , 3.81...)
Ho un misero athlon 500 con 128 mega di ram affaticato da ore di lavoro .. il fortran sara' buono ma Matlab e' eccellente (non per niente matrix lab) :)
ciao
bravi ragazzi, applicatevi ! :p
ma ...
non confondete il prodotto righe per colonne con il prodotto termine a termine ;)
Infatti nel prodotto termine a termine ci sta poco piu' di un secondo.
Per chi non si fida:
>> a
a =
1 2 3
4 5 6
7 8 9
>> b
b =
7 6 5
1 2 3
5 4 6
>> c = a*b
c =
24 22 29
63 58 71
102 94 113
>>
Chiaro? E' il prodotto tra matrici... se avessi voluto quello termine a termine:
>> d = a.*b
d =
7 12 15
4 10 18
35 32 54
Ok?
---
Questo e' il tempo di generazione (due matrici mille per mille)
elapsed_time =
0.1810
elapsed_time =
0.1500
Name Size Bytes Class
a 1000x1000 8000000 double array
b 1000x1000 8000000 double array
Grand total is 2000000 elements using 16000000 bytes
elapsed_time =
3.9150 <- La moltiplicazione
Name Size Bytes Class
a 1000x1000 8000000 double array
b 1000x1000 8000000 double array
c 1000x1000 8000000 double array
Grand total is 3000000 elements using 24000000 bytes
>>
vorrà dire che le librerie di calcolo analitico di Matlab usano codice in Fortran con algoritmi a2000 :cool:
Comunque:
non si fa CFD con Matlab;
non si fa dinamica dell'atmosfera con Matlab;
non si fa calcolo strutturale con Matlab;
non si fa simulazione di processo con Matlab;
non si fa FCA con Matlab ... :p
si fa ... didattica con Matlab ;)
Il punto non e' ottimizzare solo il codice...
D'accordo, la complessita' dell'algoritmo e' O(N^3).
Ma anche una ricerca lineare in un vettore avrebbe complessita' pari a O(N): tuttavia esistono quicksort e compagnia bella proprio per far scendere la complessita' sull'ordine di O(log2(N)).. si chiama ricerca dicotomica, tanto per fare un esempio.
Oppure non per nulla esiste il metodo di Gauss-Seidel per risolvere i sistemi lineari.. se mi dicessi: risolvi questo sistema e io lo facessi fare al Matlab potresti obiettare che ci sta troppo poco in rapporto alle operazioni che (in teoria) vanno fatte.
Ottimizzando l'algoritmo si guadagna in termini di riduzione della complessita' del problema.. ottimizzando solo il codice non e' per nulla detto che si ottenga un granche'. Per esempio, tornando alla ricerca in un vettore.. la puoi fare anche su un supercomputer ma se usi il metodo lineare ti batto anche con un 486.
Per le matrici esistono allo stesso modo algoritmi dedicati (ho trovato l'algoritmo di Strassen che arriva a ridurre la complessita' ad O(N^log2(7))
Quindi non c'e' nessuna magia dietro..
ciao
Originariamente inviato da a2000
[B]vorrà dire che le librerie di calcolo analitico di Matlab usano codice in Fortran con algoritmi a2000 :cool:
Comunque:
non si fa CFD con Matlab;
non si fa dinamica dell'atmosfera con Matlab;
non si fa calcolo strutturale con Matlab;
non si fa simulazione di processo con Matlab;
non si fa FCA con Matlab ... :p
si fa ... didattica con Matlab ;)
Io Fortran non l'ho mai usato e quindi non posso dare giudizi in merito. So solo che calcolo numerico l'ho fatto in Matlab, progettazione di controlli in Matlab, analisi dei circuiti in Matlab, studio di sistemi lineari e non in Matlab, analisi dei segnali in Matlab..
Dire che in Matlab si fa didattica e' ridicolo.. forse ti sei perso qualche versione. Simulink e' uno standard di progettazione in pratica..
Non capisco tutta questa insistenza.. non si tratta mica di un fatto personale. Stiamo parlando di linguaggi e strumenti di lavoro.
ciao
sicuro: algoritmo, codice, linguaggio, FCA, ...
Originariamente inviato da someday
[B]
Io Fortran non l'ho mai usato e quindi non posso dare giudizi in merito. So solo che calcolo numerico l'ho fatto in Matlab, progettazione di controlli in Matlab, analisi dei circuiti in Matlab, studio di sistemi lineari e non in Matlab, analisi dei segnali in Matlab..
Dire che in Matlab si fa didattica e' ridicolo.. forse ti sei perso qualche versione. Simulink e' uno standard di progettazione in pratica..
Non capisco tutta questa insistenza.. non si tratta mica di un fatto personale. Stiamo parlando di linguaggi e strumenti di lavoro.
ciao
Infatti tu hai fatto ... didattica con Matlab.
Ma se dovessi determinare i campi di temperatura-velocità-pressione-composizione non dico in un combustore ma nella tua stanza quando si apre la porta useresti Matlab ?
E per il campo elettromagnetico di una ground-plane ?
No, useresti codici scritti in Fortran. Come si deve.
Non so che dirti.. chi ci lavora avra' piacere a usare Fortran piuttosto che Matlab.. visto che non sara' il mio campo lascio questi problemi a chi li deve affrontare. :)
ciao
bravo someday,
sii sempre così, come il tuo nick:
lieve
maybe
eventuale
etereo
[opzionale]
d'altra parte in questo mondo di merda c'è posto per tutti:
Fortraniani e Cplusplani,
Matlabbisti e SQLquerofoni,
arabi e israeliani,
Samuele e la sua mamma.
MickMacello
03-04-2002, 17:15
Originariamente inviato da someday
[B]Stuzzicato dal vostro dibattito ho provato il seguente script sul mio caro Matlab:
clear all;
a = rand(1000,1000);
b = rand(1000,1000);
whos
tic;
c = a*b;
toc;
Ottengo tempi inferiori a 4 secondi (3.86 , 3.81...)
Ho un misero athlon 500 con 128 mega di ram affaticato da ore di lavoro .. il fortran sara' buono ma Matlab e' eccellente (non per niente matrix lab) :)
ciao
ehm... ma che versione di Matlab hai ?
No perchè io col mio P3 800 (nemmeno overcloccato per questa prova), 192 MB di ram e Matlab 5.3 in windows 98 faccio 19 secondi:
http://utenti.lycos.it/MickMacello/matlab.gif
oooops, :eek:
qui bisogna chiamare i Ris di Parma allora ... :p
Visto che siete tanto perplessi... vi allego l'immagine.
(Potrei sempre averla modificata)
In ogni caso, a2000, ti consiglio di fare un giro sul sito della Mathworks per vedere in che campi viene utilizzato Matlab.. puoi farti un'idea migliore da solo rispetto a cio' che posso dirti io.
ciao a tutti
bello schermo, complimenti :p
cos'è un TFT a matrice attiva ? :D :D :D
P.S.
someday ma ... someday lavory o stay sempre a cazzeggiare con Matlabbe :confused: :p
oh ca++o !!!
3 voti !!!
arrivano, anzi, vengono i nostri !!! :) :) :)
KRYHAWOK
03-04-2002, 22:01
Originariamente inviato da a2000
[B]oh ca++o !!!
3 voti !!!
arrivano, anzi, vengono i nostri !!! :) :) :)
mi mancava sta discussione...
Io non ho ancora votato...
ah, a (s)proposito, mi è arrivato .... la Fabia ?
no il Compaq VisualFortran :cool:
cioè, per dire, tra le proprietà delle ComboBox puoi settare anche il controscappellamento [sinistro|destro] :eek:
ca++i amari per VisualC++ .... :p
MickMacello
04-04-2002, 14:24
Originariamente inviato da cionci
[B]MickMacello : io sono a 3.2 s con un Tbird 1333...con l'algoritmo di a2000 ottimizzato da me...ma già a 1000 Mhz sono a 3.8 s, quindi il mio algoritmo è bandwidth limited, come probabilmente il tuo...
cionci mi manderesti il tuo lavoro ?
vorrei vedere dove sbaglio, dato che non riesco a scendere sotto i 5.4 s.
register double *ai, *aj, *aii, *ajMax, tmp;
register int i, j, ind1, ind2, maxInd1, maxInd2;
for(i=0; i<1000; i+=10)
{
for(j=0; j<1000; j+=10)
{
maxInd1 = i+10;
for(ind1=i; ind1<maxInd1; ++ind1)
{
ai = m+ind1;
aj = m2+j;
maxInd2 = j+10;
for(ind2=j; ind2<maxInd2; ++ind2, ++aj)
{
ajMax = aj + 1000;
aii = ai;
tmp = 0;
for(; aj<ajMax; ++aj,++aii)
tmp += *aii * *aj;
*(m3+ind1*1000+ind2)=tmp;
}
}
}
}
Le matrici m e m3 sono memorizzate in un vettore di 1000x1000 per riga, m2 è memorizzata sempre in un vettore 1000x1000, ma per colonna (in pratica è la trasposta della matrice memorizzata per colonna)...
MickMacello
04-04-2002, 16:30
mille grazie :)
MickMacello
05-04-2002, 14:38
cionci prova questa modifica :
for(i=0; i<dim;++i)
for(j=0; j<dim;++j)
{ai = m+i;
aj = m2+j;
ajMax = aj + dim;
aii = ai;
tmp = 0;
for(; aj<ajMax; ++aj,++aii)
tmp += *aii * *aj;
*(m3+i*dim+j)=tmp;
}
mi sono accorto che va più veloce se anzichè calcolare di 10 in 10 si va di uno in uno. Ho guadagnato.... niente m'ero sbagliato.
ah ehm dim è la dimensione della matrice (=1000).
MickMacello
05-04-2002, 17:28
ultimo post poi prometto che non rompo più ;)
Ikitt tu che hai un gran bel pezzo di processore proveresti il programmino che allego ?
Ho inserito sia il sorgente che l' eseguibile compilato su RH7.2
opzioni cosigliate per compilarlo:
-O3 -funroll-loops
e nient' altro.
L'algoritmo non funziona...nè il tuo nè il mio...avevo fatto un piccolo errore...
Comunque correggendolo riesco ad ottenere 4,1 secondi... con il tuo sempre correggendolo vado a 18 secondi...
Il mio :
register const int dim = 1000, num = 25;
register double *ai, *aj, *aii, *ajMax, tmp;
register int i, j, ind1, ind2, maxInd1, maxInd2, count = 0;
for(i=0; i<dim; i+=num)
for(j=0; j<dim; j+=num)
for(maxInd1 = i+num, ind1=i; ind1<maxInd1; ++ind1)
for(ai = m+ind1*dim, aj = m2+j*dim, maxInd2 = j+num, ind2=j; ind2<maxInd2; ++ind2, ++aj)
{
for(ajMax = aj + dim, aii = ai, tmp = 0; aj<ajMax; ++aj,++aii)
tmp += *aii * *aj;
*(m3+ind1*dim+ind2) = tmp;
}
Il tuo :
for(i=0; i<dim;++i)
for(j=0; j<dim;++j)
{
for(aj = m2+j*dim, aii = m+i*dim, ajMax = aj + dim, tmp = 0; aj<ajMax; ++aj,++aii)
tmp += *aii * *aj;
*(m3+i*dim+j) = tmp;
}
MickMacello
05-04-2002, 20:24
azz azz...
in effetti dopo aver postato mi sono accorto che qualcosa non andava però pensavo di non aver capito come avevi memorizzato la matrice trasposta.
Bhe suppongo che le mie modifiche portassero giovamento solo con la versione originale.
Ragazzi, questo sì che si chiama amore per la scienza !!!
Ancora un pò di allenamento e poi ci buttiamo a bomba sugli algoritmi per i sistemi di equazioni differenziali stiff.
A noi Adams-Bashforth, Adams-Moulton e Gear ci fanno una pu+++tta.
Avanti Savoiaaaaaa
Non si vede un ca++o :mad:
E' meglio così ?
Ragazzi, questo sì che si chiama amore per la scienza !!!
Ancora un pò di allenamento e poi ci buttiamo a bomba sugli algoritmi per i sistemi di equazioni differenziali stiff.
A noi Adams-Bashforth, Adams-Moulton e Gear ci fanno una pu+++tta.
Avanti Savoiaaaaaa
Originariamente inviato da MickMacello
[B]Bhe suppongo che le mie modifiche portassero giovamento solo con la versione originale.
In effetti... Ma tu quale compilatore usi ?
a2000 : ma quante ore ci metti a scrivere un messaggio ? Oppure hai fatto un procedura in VBA che ti automatizza tutto ? :p
sì, questa:
Function f_ppp(a$) As String
Dim c$(1 To 5)
c$(1) = "red"
c$(2) = "orange"
c$(3) = "yellow"
c$(4) = "green"
c$(5) = "blue"
b$ = ""
ic% = 2
For i% = 1 To Len(a$)
a1$ = Mid$(a$, i%, 1)
ic% = 1 + i% Mod 5
b$ = b$ + "[colo r=" + c$(ic%) + "]" + Mid$(a$, i%, 1) + "[/colo r]"
'eliminare lo spazio in "colo r" -> "color" !!!!
Next i%
f_ppp = b$
End Function
modificabile a [/siz]
:p
P.S.
naturally in Excel-VBA allegato
E io che te lo domando anche :o :)
scusate se mi intromemetto ma la discussione mi piace ok non so programmare a parte un po' i plc che sono in una sorta di pascal molto limitato a calcoli sugli ingressi e uscite di tensione; ma cmq volevo dire che io ho il bus delle memorie a 170 e potevo provare con le ddr portate a 340 quanti si guadagna in termini di di bandwith coi vostri codici ... ho un tb 1400 @1250 (core rotto :buaaaa )
se volete mandarmeli la mia e-mail e' avemagno@tin.it
lo so sono un mitomane :D
basta PLC !
viva il controllo distribuito con microcontrollori on site, PC master e bus di campo :p
Comunque benvenuto,
i forum sono l'unica eccezione alla regola: "meno siamo, meglio stiamo" :)
qaunto ti do' ragione lanno scorso l'ho odiato alla matura quello schifo di "piattaforma" avevamo fatto un controllare di stampa automatico che dalla porta rs232 del pc passava al plc il quale a scansioni di tempo faceva dei calcoli e li mandava al pc il quale stampava il listato .. da morire andava mai una sega soprattutto la temporizzazione che gia a 100 hz impazziva una schifezza... forse era solo il nostro plc che era sdozzo; bha non so ma ci voleva veramente pozo a metterl oin crisi per non parlare poi del fatto che le entrate e uscite erano a 24 v e quindi giu' di foto accoppiatori per cercare di dargli un segnale da 12@24 ...3 mesi ci abbiamo messo ..... penso l'abbiate capito preferisco l'HW al software ecco perche' il plc mi piaceva .. adesso cmq m iapicerebbe averne uno per farci qualche cagata ma costano parecchio quelli buoni e cmq con un bel po' di i/o
allroa cionci mi ha mandato il suo eseguibile....
il risultato con bt a 7.5*166 e' 5,719 sec
dopo provo col bus a 170 o 171
non so a lui quanto ci metteva ma mi sembra buono cmq
Strano...a me ci mette 4.1 secondi...il tutto @1333 Mhz...
bhe io sto a 1250 allroa abbiamo dimostrato che la ram non centra nulla in questi calcoli
Magari hai qualcosa di peso che gira in background...perchè a me @1200 mi fa 4.6 secondi...
chiudendo tutto 5.2 sec ..... ma ci vuole qualcosa di aprticolare installato sul sitema per caso ????? librerie eccc ecc
Nono...che sistema oeprativo hai ?
win 98SE ho messo ora le ram a cas 2 nulla nion cambia niente
Io ho Windows 2000...boh...sarà quello...
Ora sono @1466 con il mio millino...e CVD stesso tempo che a 1333...
MickMacello
06-04-2002, 21:27
è sicuramente il S.O. perchè anche a me win98se dà risultati nettamente peggiori rispetto a XP.
bho la cosa mi lascia perplesso soprattutto ora che ho un litro di birra in corpo .. bah :D
/\/\@®¢Ø
10-04-2002, 14:57
Beh, sembra sia diventato un "must" partecipare a questa gara.
Lo faccio anche io a modo mio...
#include <iostream>
#include <ctime>
#include <cstdlib>
#include "Vector.hpp"
#define dim 1000
int main()
{
Matrix A( dim , dim );
Matrix B( dim , dim );
Matrix C( dim , dim );
clock_t ck1 , ck2;
float tempo;
for ( size_t i =0 ; i< dim ; i++ )
for ( size_t j = 0 ; j<dim ; j++ )
{
A(i,j) = (float)0.0;
B(i,j) = static_cast<float>(rand());
C(i,j) = static_cast<float>(rand());
}
std::cout << "begin..." << endl;
ck1 = clock();
A = B*C; // :D
ck2 = clock();
tempo=(float)(ck2-ck1)/CLOCKS_PER_SEC;
std::cout << "secondi: " << tempo << '\n';
}
Si lo so , ho imbrogliato , visto che mi solo limitato a scrivere un wrapper per le BLAS, pero' e' molto carino :D
( e funziona bene visto che con matrici di float l'esempio sopra ci mette 11.43 secondi sul mio povero p2-233 ;) ).
bhe se me lo passi provo a vedere sul mio tb se funge meglio sono curioso..
/\/\@®¢Ø
10-04-2002, 19:33
Ok, prima pero' mi riservo di ricontrollare il codice, che sicuramente conterra' ancora un sacco di errori.
Nel frattempo devi scaricarti le librerie che ho utilizzato.
Le ATLAS ( www.netlib.org/atlas ) contengono sia le librerie originali BLAS ( in Fortran ) che il wrapper in C cblas.
Ricompilandole dovresti riuscire ad ottenere una versione ottimizzata che utilizza le eventuali estensioni ( 3dnow / sse ).
Con le SSE in particolare se non sbaglio dovrebbe riuscire a fare calcoli su 4 float al colpo ( :eek: ) e le SSE2 su due double al colpo.
( Se usi windows temo tu debba cercarti una versione apposita, i sorgenti che ti ho indicato dovrebbero essere per unix ).
Tratto da un libro di algoritmi:
In the years that have elapsed since Strassen's original paper many researchers have been whittling away at the exponent of N in the complexity bounds. Several new, and more elaborate algorithms have been developed, and the exponent, which was originally 3, has progressed downwards through 2.81 to values below 2.5.
It is widely believed that the true minimum exponent is 2+epsilon: that two NxN matrices can be multiplied in time O(N^2+epsilon ), but there seems to be a good deal of work to be done before that result can be achieved.
Insisto quindi nel ricordarvi che e' inutile vedere chi fa prima, senza pensare all'algoritmo che si utilizza.
Quindi se Matlab va tanto bene sul mio misero 500 ci sara' un motivo sotto.
Seconda cosa.. i tempi che qualcuno aveva stimato 'impossibili' in relazione ai MHz devono esser pesati tenendo conto dell'architettura dei computer attuali.. non stiamo lavorando su una macchina di Turing, ma son tutte CPU superscalari con un certo grado di parallelismo. Quindi ottimizzato o non ottimizzato che sia il codice, se puo', ci pensa la CPU a fare i conti in parallelo.. e tra un 486 e un Pentium * non sono solo i MHz a far la differenza.
ciao a tutti
Originariamente inviato da someday
[B]Insisto quindi nel ricordarvi che e' inutile vedere chi fa prima, senza pensare all'algoritmo che si utilizza.
Quindi se Matlab va tanto bene sul mio misero 500 ci sara' un motivo sotto.
Infatti io stavo cercando l'algoritmo migliore...
Originariamente inviato da someday
[B]Seconda cosa.. i tempi che qualcuno aveva stimato 'impossibili' in relazione ai MHz devono esser pesati tenendo conto dell'architettura dei computer attuali.. non stiamo lavorando su una macchina di Turing, ma son tutte CPU superscalari con un certo grado di parallelismo. Quindi ottimizzato o non ottimizzato che sia il codice, se puo', ci pensa la CPU a fare i conti in parallelo.. e tra un 486 e un Pentium * non sono solo i MHz a far la differenza.
Certo che non sono solo i Mhz...ma ricordati che il codice ha una certa sequenza da rispettare, quindi ripeto che, secondo me, il limite inferiore di questo problema è sicuramente superiore ad una istruzione floating point completata per ciclo di clock (sono 2 miliardi di istruzioni floating point, abbonando quelle su interi e le istruzioni di controllo di flusso che possono sfruttare l'out of order execution e il parallelismo sulle unità del processore)...
Originariamente inviato da cionci
[B]
Certo che non sono solo i Mhz...ma ricordati che il codice ha una certa sequenza da rispettare, quindi ripeto che, secondo me, il limite inferiore di questo problema è sicuramente superiore ad una istruzione floating point completata per ciclo di clock (sono 2 miliardi di istruzioni floating point, abbonando quelle su interi e le istruzioni di controllo di flusso che possono sfruttare l'out of order execution e il parallelismo sulle unità del processore)...
Il codice ha una certa sequenza da rispettare.. dipende..
Dal Pentium Pro in avanti sono state introdotte tecniche avanzate di gestione e predizione del flusso esecutivo. In un prodotto tra matrici, dove si puo' suddividere il tutto in blocchi indipendenti tra loro, penso che il parallelismo che una qualsiasi CPU del dopo-Pentium possa raggiungere sia considerevole.
ciao
Originariamente inviato da someday
[B]Il codice ha una certa sequenza da rispettare.. dipende..
Dal Pentium Pro in avanti sono state introdotte tecniche avanzate di gestione e predizione del flusso esecutivo. In un prodotto tra matrici, dove si puo' suddividere il tutto in blocchi indipendenti tra loro, penso che il parallelismo che una qualsiasi CPU del dopo-Pentium possa raggiungere sia considerevole.
Per farti un esempio di precedenza... Quando si vanno a moltiplicare due elementi e poi a sommare il risultato in un elemento della terza matrice, la moltiplicazione va eseguita assolutamente prima dalla somma e così riduci già alla metà le possibili operazioni floating point da eseguire in parallelo...
Tutte le tecniche di branch-prediction possono sicuramente aumentare il parallelismo fra unità (ad esempio nell'Athlon possono essere occupate fino a 9 unità distinte nello stesso tempo), ma in questo caso non sulle unità FPU...infatti, anche se composta da 3 unità di calcolo come nell'Athlon, la FPU non fa in tempo ad essere impegnata da 2 o 3 istruzioni floating-point, visto che le 2 istruzioni FPU + vicine non possono essere svolte parallelamente (somma e prodotto) e una terza istruzione si troverebbe in una fase della pipeline che non ha ancora impegnato la FPU...
Originariamente inviato da someday [/]
[B]Tratto da un libro di algoritmi:
In the years that have elapsed since Strassen's original paper many researchers have been whittling away at the exponent of N in the complexity bounds. Several new, and more elaborate algorithms have been developed, and the exponent, which was originally 3, has progressed downwards through 2.81 to values below 2.5.
It is widely believed that the true minimum exponent is 2+epsilon: that two NxN matrices can be multiplied in time O(N^2+epsilon ), but there seems to be a good deal of work to be done before that result can be achieved.
Insisto quindi nel ricordarvi che e' inutile vedere chi fa prima, senza pensare all'algoritmo che si utilizza.
Quindi se Matlab va tanto bene sul mio misero 500 ci sara' un motivo sotto.
Seconda cosa.. i tempi che qualcuno aveva stimato 'impossibili' in relazione ai MHz devono esser pesati tenendo conto dell'architettura dei computer attuali.. non stiamo lavorando su una macchina di Turing, ma son tutte CPU superscalari con un certo grado di parallelismo. Quindi ottimizzato o non ottimizzato che sia il codice, se puo', ci pensa la CPU a fare i conti in parallelo.. e tra un 486 e un Pentium * non sono solo i MHz a far la differenza.
ciao a tutti [/quote][/size]
carissimo,
fai bene a leggere ... ma poi bisogna anche scrivere ossia cimentarsi e/o giocarsi i C++lioni con la vita (e la programmazione).
E' chiaro che nella galassia ci sarà sempre qualcuno più bravo dalle cui librerie si può direttamente attingere 'senza reinventare la ruota'.
Ma è un pò come accontentarsi di guardare Rocco Siffredi perchè è inutile reiventarsi l'uccello. :p
Ma non è detto !!!
Quindi: "programmate, programmate, qualcosa resterà !" ;)
E basta co' sti data-base e Combo-box, che mi sembrate tanti 15-enni brufolosi che devono fare vedere alla mammina-morosina che sanno fare le formine al compiuters. :eek:
Se proprio volete stupire con effetti speciali fatevi un frattalino di Julia (ah Giulia, Giulia t'arri-membri ancor ... ) oppure un bel modellatore geometrico con un modello 3D dinamico dell'amato corpo dell'amata, con cui raggiungerLe il .... cuore !!! :D :D
P.S.
ricordo sempre che il traguardo della 1000*1000 di Le Matr, è a 2.34 €, pardon s, con Tb1400. ;)
a2000 : ma tu hai delle ram DDR ?
PS: bella quella su Rocco Siffredi...
mi piace che sta tornando fuori l'ingegnere che sarà in te !!!
no, niente DDR. solo 512 Mb di PC100.
Originariamente inviato da KRYHAWOK
[B].... con una frase molto simile ha esordito la mia prof. di informatica, che non riusciva neppure a spiegare a sè stessa perchè nel programma delle lezioni fossero incluse una decina di ore sul Fortran_77.....
Da quel poco che ho visto è uno dei linguaggi più inutili, vecchi, astrusi, contorti che abbia mai visto...il Basic a confronto è una potenza divina!
OK, ammetto che in 10 ore di lezione (solo teoriche) non si può conoscere un linguaggio, ma vi garantisco che mi sono bastate. Ribadisco, è semplicemete INUTILE.
PS: fra 14 ore circa ho l'esame (anche) sul fortran e sono qui a postare... mah....
praticamente quasi tutto il software piu' avanzato in materia ingegeristico-matematica e' scritto in fortran
Originariamente inviato da taddeus
[b]
praticamente quasi tutto il software piu' avanzato in materia ingegeristico-matematica e' scritto in fortran
ecco uno massiccio !
Originariamente inviato da taddeus
[B]praticamente quasi tutto il software piu' avanzato in materia ingegeristico-matematica e' scritto in fortran
Sul matematico siamo d'accordo, ma sull'ingegneristico....permettimi di sollevare qualche dubbio...anche perchè da noi, su tanti indirizzi che abbiamo, non ce n'è uno che ha un corso in cui fanno il Fortran...
Originariamente inviato da cionci
[B]
Sul matematico siamo d'accordo, ma sull'ingegneristico....permettimi di sollevare qualche dubbio...anche perchè da noi, su tanti indirizzi che abbiamo, non ce n'è uno che ha un corso in cui fanno il Fortran...
infatti voi non fate ingegneria ;)
MickMacello
14-04-2002, 19:24
uè uè andiamoci piano :rolleyes:
io mi sono cuccato calcono numerico, meccanica razionale, teoria del controllo, controllo dei processi, robotica industriale, ingegneria dei sistemi di controllo, elettronica dei sistemi digitali e mi vieni a dire che non faccio ingegneria ? :p :mad: :p
Originariamente inviato da a2000
[B]infatti voi non fate ingegneria ;)
Guarda che io no parlavo di ingegneria informatica...parlavo di tutti gli indirizzi di ingegneria a Pisa...non c'è un corso in cui si fa il Fortran...
Originariamente inviato da cionci
[B]
Sul matematico siamo d'accordo, ma sull'ingegneristico....permettimi di sollevare qualche dubbio...anche perchè da noi, su tanti indirizzi che abbiamo, non ce n'è uno che ha un corso in cui fanno il Fortran...
mah, per molte applicazioni (CFD, FEM, ed altre) il FORTRAN la fa ancora da padrone, comunque intendevo ingegneria classica (elettrica, meccanica e strutturale) e non informatica
Originariamente inviato da taddeus
[B]mah, per molte applicazioni (CFD, FEM, ed altre) il FORTRAN la fa ancora da padrone, comunque intendevo ingegneria classica (elettrica, meccanica e strutturale) e non informatica
Infatti, nemmeno io intendevo ingegneria informatica...ripeto, fra tutti i vari indirizzi di ingegneria a Pisa, non c'è un corso in cui viene fatto il Fortran...
ma infatti a Pisa c'è un solo problema di ingegneria: rubare il mare ai livornesi :D :D
non vi serve il Fortran, basta una cannuccia ! :D :D
lascia fare cionci ... e quando ti sdrai supino in piazza dei miracoli guarda le nuvole come si muovono e pensa in Fortran, guarda la Torre raddrizzata e pensa in Fortran,
guarda sotto la gonna della cosciona a fianco che dopo tre quarti d'ora di inutile attesa di una tua minima avances si è stufata e si è alzata, ... e pensa in FCA. :p
Originariamente inviato da cionci
[B]
Infatti, nemmeno io intendevo ingegneria informatica...ripeto, fra tutti i vari indirizzi di ingegneria a Pisa, non c'è un corso in cui viene fatto il Fortran...
effettivamente il fortran e' ritenuto obsoleto, chi si occupa di certe cose deve impararlo da se', d'altronde nei corsi di meccanica, elettrotecnica e ing strutturale non mi pare esistessero esami fondamentali d'informatica se non calcolo numerico; ovviamente parlo relativamente a corsi di laurea concepiti fino ad una decina d'anni fa
MickMacello
02-05-2002, 19:39
bah, sono perplesso:
Red Hat 7.2
Intel fortran compiler 5
Intel C++ compiler 5
p3 800
versione di cionci in C++ : 8.2 secondi
versione di a2000 in fortran : 6.3 secondi
come prima ma con p3 @992
versione di cionci in C++ : ~5.1 secondi
versione di a2000 in fortran : ~5.1 secondi
:confused: :confused: :confused:
Ganzo ;)
Dopo tutto mi sono basato sull'algoritmo di a2000...
KRYHAWOK
03-05-2002, 01:01
Salve carissimi.
Dato che mi sono affezionato a sto topic, mi arrogo il diritto di mandarlo un po' OT...
Dacchè qui il livello ingegneristico tocca livelli mai visti dai tempi del buon vecchio Leo, sicuramente mi potrete aiutare... Quel che cerco è un software di fitting matematico sia per funzioni R -> R che R^2 -> R; se magari fosse disponibile in rete in qualche angolo sarebbe meglio...
Non dico che non saprei realizzarlo in BASIC, ma sapete... sono molto impegnato....
Grazie gente.
Ma che deve fare ? Lo studio delle funzioni ?
Originariamente inviato da KRYHAWOK
[B]Salve carissimi.
.... ma sapete... sono molto impegnato....
Grazie gente.
mitoooooo !
cioè, mi vengono in mente diverse cose su cui potresti essere impegnato .... molte di queste vietate ai minori di anni 18 :p
direi che la più 'ingegneristica' potrebbe essere l'acquisto di vernice acrilica e stoffa per gli striscioni di domenica :D :D
KRYHAWOK
03-05-2002, 12:59
Esatto.. :o Gran parte delle cose che mi tengono occupato sono proprio vietate ai minori di 18, ma, sai, mi ci sono affezionato.
Cmq, il programma che cercavo dovrebbere essere in grado di approssimare dei dati sperimentali con delle funzioni (fitting, appunto).
Per fare un esempio banale R -> R: dati dei valori di spazio in funzione del tempo rilevati sperimentalmente, il sw dovrebbe proporre l'equazione della curva che meglio approssima i punti del grafico x(t)= ecc....
Problema standard.
Per un approccio very fast ti consiglio, prova a indovinare, esatto: Excel. :p
1) per l'interpolazione di punti sperimentali di relazioni R->R esiste già nella procedura guidata per la costruzione guidata di grafici l'opzione per determinare i parametri e l'andamento della funzione di best-fit (minimi quadrati) con interpolanti polinomiali dal 1° al 6° ordine, curve logaritmiche, esponenziali, ecc.
2) per l'interpolazione lineare o non lineare (ricordo rispetto ai parametri) di punti sperimentali di relazioni Rm -> Rn con funzioni di errore a piacere puoi minimizzare la somma dei quadrati delle funzioni di errore (o in generale una opportuna funzione semidefinita positiva degli errori) con il Risolutor.
lascio i dettagli tecnici come esercizio o in alternativa in cambio di una partecipazione ai tuoi impegni .... :cool:
/\/\@®¢Ø
03-05-2002, 14:41
Originariamente inviato da KRYHAWOK
[B]Esatto.. :o Gran parte delle cose che mi tengono occupato sono proprio vietate ai minori di 18, ma, sai, mi ci sono affezionato.
Cmq, il programma che cercavo dovrebbere essere in grado di approssimare dei dati sperimentali con delle funzioni (fitting, appunto).
Per fare un esempio banale R -> R: dati dei valori di spazio in funzione del tempo rilevati sperimentalmente, il sw dovrebbe proporre l'equazione della curva che meglio approssima i punti del grafico x(t)= ecc....
Se lavori sotto linux, con gnuplot dovresti riuscire a fare questo, anche se non l'ho provato personalmente
MickMacello
03-05-2002, 19:16
Fermi tutti:
cionci se non sono ubriaco il tuo programma è ancora sbagliato. Funziona solo per num=1. Fai una prova con dim=4 e num=2 e vedi...
A questo punto mi sono basato sull' algoritmo di a2000, tradotto in fortran e c++. I risultati sono questi:
Linux Red Hat 7.2
P3 @ 992 e 192MB con FSB a 124MHz
Intel Fortran compiler 5
Intel C++ compiler 5
versione C++ : ~5.7 secondi
versione fortan : ~4.95 secondi
Stando così le cose direi che il C/C++ se la cava benone:
è solo il 15% più lento.
Resta aperta una questione: come fa a2000 a fare 2.34 secondi ?
Eppure mi sembra di aver seguito pedissequamente le linee guida della sua soluzione.
Lascio a voi la risposta perchè io ora mi sono veramente rotto i maroni :D
Allego i files risultato delle mie fatiche (compreso quello in fortran così a2000 mi dice se ho omesso qualcosa di importante), buon divertimento. :D
Ora provo...ma mi sembra di averlo già provato... Magari avrò modificato qualcosa di troppo... Domani guardo...
Originariamente inviato da MickMacello
[B]
...
Resta aperta una questione: come fa a2000 a fare 2.34 second ?
Eppure mi sembra di aver seguito pedissequamente le linee guida della sua soluzione.[/size]
Lascio a voi la risposta perchè io ora mi sono veramente rotto i maroni :D
...
mo socciia, mo alora se ti scei rotto i maroni mettila ben su la provenienza che mi sa che anche a te "i fatti ti cosano" ... :cool:
non sarai mica anche tu del paese di [/siz] :D :D
MickMacello ... Zucchero ... Blasco ... Ligabue ... nebbia birra e rutto libero .......
vedo vedo ......
la brughiera tra Mudna (Modena) e Rezzo (Reggio) ... :eek:
MickMacello
03-05-2002, 21:50
Originariamente inviato da cionci
[B]Ora provo...ma mi sembra di averlo già provato... Magari avrò modificato qualcosa di troppo... Domani guardo...
Scaricati il mio allegato, c' è anche la tua versione scritta da me, così vedi se ho sbagliato qualcosa (non mi sembra cmq).
/\/\@®¢Ø
03-05-2002, 22:14
errore...
/\/\@®¢Ø
03-05-2002, 22:15
ancora...
MickMacello
03-05-2002, 23:25
Originariamente inviato da a2000
[B]
mo socciia, mo alora se ti scei rotto i maroni mettila ben su la provenienza che mi sa che anche a te "i fatti ti cosano" ... :cool:
non sarai mica anche tu del paese di :D :D
Se dise maroni anca a Venexia ;)
Originariamente inviato da MickMacello
[B]
Se dise maroni anca a Venexia ;)
e se dise anca [/siz]
Scusate, non è mia intenzione provare perchè non ho voglia di pensare :p ma se qualcuno ha voglia di riscrivere la versione C++ dell'algoritmo di a2000 in C può provare questo (su linux) e i tempi dovrebbero migliorare, anche se non saprei dire di quanto perchè le chiamate a memcpy non sono molte, ma essendo in un ciclo...
anzichè chiamare memcpy, sprecando tempo chiamando una funzione :p si può usare lo stesso algoritmo ficcato in una define, usando la versione scritta in assembly inline per linux :D
#define memcpy2(to, from, n) \
{ \
int d0, d1, d2; \
__asm__ __volatile__( \
"rep ; movsl\n\t" \
"testb $2,%b4\n\t" \
"je 1f\n\t" \
"movsw\n" \
"1:\ttestb $1,%b4\n\t" \
"je 2f\n\t" \
"movsb\n" \
"2:" \
: "=&c" (d0), "=&D" (d1), "=&S" (d2) \
:"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from) \
: "memory"); \
}
volendo si può fare la stessa cosa per la funzione rand, ma usando una normale define visto che la funzione non è un granchè complessa, così si risparmiano un po' di chiamate di funzione :p
ciao
/\/\@®¢Ø
11-05-2002, 17:53
Ma a questo punto, usare una libreria no ? :D:D:D
beh ma qui hai il vantaggio che non fai chiamate a funzione ripetute migliaia di volte... ho fatto un po' di prove copiando una stringa un miliardo di volte :D usando la define e usando memcpy come funzione (nb che il codice è lo stesso solo che per la define non viene chiamata nessuna funzione) e i risultati sono stati 24s per la define e 30 per la chiamata di funzione...
ciao
/\/\@®¢Ø
11-05-2002, 18:14
quel che intendo dire e' che oltre un certo punto se proprio si hanno bisogno di performance estreme, tanto vale utilizzare librerie apposite, visto che esistono un sacco di ottimizzazioni anche piu' estreme che pero' dipendono dalla cpu. Non solo usare estensioni tipo SSE , ma anche ( ad esempio ) copiare le matrici in zone contigue per sfruttare al meglio la cache, etc.
Infatti avevo pensato diusare mmx_memcpy :D ma chiama alcune funzioni all'interno del kernel come kernel_fpu_begin() quindi si perde il vantaggio :D... bisognerebbe scriversela a mano :D
ops... in realtà usando la stessa funzione (linux) e non quella di libreria il guadagno è minimo, circa 1 secondo...
e usando l'opzione -O si perdono tutti i vantaggi probabilmente perchè in realtà la funzione chiamata usa mmx o 3dnow ed è "inline"... ho perso :( :D
MickMacello
11-05-2002, 20:15
a volte ritornano :eek: :eek:
alexmaz ho usato la memcpy perchè fa parte della libreria standard del C. Ovviamente si potrebbe scrivere tutto in assembler all' interno di un sorgente C, ma a questo punto come si può chiamarlo C ?
idem per le funzioni/librerie ottimizzate per certi processori: non fanno parte dello standard per quanto ne so io. A mio parere per rimanere fedeli alla sfida C/C++ vs fortran ci si può appoggiare solo alle opzioni di ottimizzazione disponibili nei compilatori.
Allora uno mette -O3 e tutte le funzioni sono inline... Certamente diventerebbe + veloce :)
MickMacello
11-05-2002, 20:33
è ciò che ho fatto, non l' ho specificato ma ho usato per entrambi i progz (sia f sia c) le ottimizzazioni migliori che ho trovato.
Tra parentesi non ho notato differenze apprezzabili tra -O2 e -O3.
Bah, dato che alla fine tutto finisce in linguaggio macchina, l'unico vantaggio che il fortran può avere su C e C++ sono delle librerie ottimizzate, IMHO... io cercavo di riportare la situazione in parità :p
magomerlinopaolo
11-05-2002, 22:33
diamine sono 1 ora che leggo tutto sto topic anf anf sembrava non voler terminare + :)
sentite io sono un newbie che programma in delphi, e vi dico che il delphi fa i baffi sia al C++ che al fortran :P così chiudiamo la discussione di chi dei due è + veloce, DELPHI RULEZ ;)
a parte gli scherzi, vabbè che sono quasi mezzanotte e sto dormendo cmq mi spiegate sta matrice 1000x1000 con cosa bisogna riempirla e che calcoli bisogna fare? passo la sfida al mio GURU informatico che può fare qusto programma in delphi :)
Originariamente inviato da alexmaz
[B]Bah, dato che alla fine tutto finisce in linguaggio macchina, l'unico vantaggio che il fortran può avere su C e C++ sono delle librerie ottimizzate, IMHO... io cercavo di riportare la situazione in parità :p
Infatti...è quello che ho sempre sostenuto...senza tener conto che quelle librerie potrebbero anche essere usate in C o C++ o in qualsiasi altro linguaggio con le pa@@e...
/\/\@®¢Ø
12-05-2002, 12:34
Originariamente inviato da alexmaz
[B]Bah, dato che alla fine tutto finisce in linguaggio macchina, l'unico vantaggio che il fortran può avere su C e C++ sono delle librerie ottimizzate, IMHO... io cercavo di riportare la situazione in parità :p
Beh, non e' proprio cosi' secondo me.
Il fatto che il Fortran sia un linguaggio piu' semplice per certi versi, permette al compilatore di 'capire' che puo' usare certi trucchetti per ottimizzare il codice. Senza contare il fatto che memorizzare le matrici in singoli array ( invece che in array di array ) ha i suoi vantaggi...
Originariamente inviato da /\/\@®¢Ø
[B]Beh, non e' proprio cosi' secondo me.
Il fatto che il Fortran sia un linguaggio piu' semplice per certi versi, permette al compilatore di 'capire' che puo' usare certi trucchetti per ottimizzare il codice. Senza contare il fatto che memorizzare le matrici in singoli array ( invece che in array di array ) ha i suoi vantaggi...
Infatti...è prprio la strada che avevo preso io...memorizzare le matrici in vettori e minimizzare gli accessi in memoria sfruttando il + possibile la cache...
Dal mio punto di vista, e per quello che mi è dato a sapersi sul F_77, penso che si possa decisamente eliminare dalla faccia della terra!:D
Onestamente parlando, però, penso che possa essere, ancor oggi, utile ad uno studente che si appresta alla programmazione. Lo reputo molto educativo, anche se non particolarmente stimolante. :)
Originally posted by "czame"
Dal mio punto di vista, e per quello che mi è dato a sapersi sul F_77, penso che si possa decisamente eliminare dalla faccia della terra!:D
....
ma nel computer c'avete la CPU o la CePU ?
:p
scusate ma tutte le disquisizioni sui linguaggi specie su quelli che si trovano free come il fortran 77 sono del tutto fuori luogo, se ad uno va di programmare in fortran perche' non dovrebbe farlo? io ho lo preferisco al visual basic ad esempio ma qualcuno potrebbe non essere daccordo con me, ad ogni modo e' standard portatile ed efficente non ci si possono scrivere tutti i programmi che uno vorrebbe ma quale linguaggio in realta' puo' di fatto fare questo?
per me la discussione si puo' anche chiudere.
Originally posted by "homero"
non ci si possono scrivere tutti i programmi che uno vorrebbe ma quale linguaggio in realta' puo' di fatto fare questo?
Passi per il Fortran, ma su questo non sono d'accordo...
Tutti i programmi si possono fare con il Fortran (anche quelli VisualMinchia), ma i programmi che fanno cose serie (codici di calcolo numerico) si possono fare SOLO con il Fortran per:
velocità di calcolo,
efficienza di compilazione,
similitudine con il linguaggio algebrico (che è Il Linguaggio),
stile ed estrazione della comunità che lo utilizza,
potenza dei calcolatori che lo usano come linguaggio fondamentale.
:cool:
cionci: mi sta bene che non sei d'accordo ma almeno fornisci un esempio, il C/C++ che quello a piu' ampio spettro di utilizzo ha comunque delle lacune sulla programmazione distribuita, ossia e' necessario cambiare gli algoritmi per passare da calcolo single treand a quello multitreand e viceversa.
a2000:
fortran, matlab mathematica e chi piu' ne ha piu' ne metta comprese le innumerevoli c/c++ libraries che possono essere usate con qualunque compilatore.
comunque il g77 e' un gran bel compilatore inoltre e' free...
Originally posted by "homero"
cionci: mi sta bene che non sei d'accordo ma almeno fornisci un esempio, il C/C++ che quello a piu' ampio spettro di utilizzo ha comunque delle lacune sulla programmazione distribuita, ossia e' necessario cambiare gli algoritmi per passare da calcolo single treand a quello multitreand e viceversa.
Ok...ma comunque ci puoi fare tutto...
Poi un appunto...C e C++ non sono un unico linguaggio...
Non mi risulta che in Fortran abbiano fatto sistemi operativi...
Originally posted by "homero"
....
a2000:
fortran, matlab mathematica e chi piu' ne ha piu' ne metta comprese le innumerevoli c/c++ libraries che possono essere usate con qualunque compilatore.
prova a simulare i campi di T, P, v, x quando apri la porta della tua stanza (per dire) con "matlab mathematica e C/C++".
caro mio, col pane duro (e contro tomawak e cruise) ci vogliono "attrezzi adeguati" e bisogna prepararsi per tempo.
:cool:
Stalingrado
Fame e macerie sotto i mortai
Come l'acciaio resiste la citta'
Strade di Stalingrado, di sangue siete lastricate;
ride una donna di granito su mille barricate.
Sulla sua strada gelata la croce uncinata lo sa
d'ora in poi trovera' Stalingrado in ogni citta'.
L'orchestra fa ballare gli ufficiali nei caffe',
l'inverno mette il gelo nelle ossa,
ma dentro le prigioni l'aria brucia come se
cantasse il coro dell'Armata Rossa.
La radio al buio e sette operai,
sette bicchieri che brindano a Lenin
e Stalingrado arriva nella cascina e nel fienile,
vola un berretto, un uomo ride e prepara il suo fucile.
Sulla sua strada gelata la croce uncinata lo sa
d'ora in poi trovera' Stalingrado in ogni citta'.
in cosa consisteva la sfida ? :cool:
Cionci puoi postare l'esempio sfida in C/C++ ? ;)
up, l'esempio in C/C++ verrà considerato esclusivamente sotto ad un punto di vista prettamente didattico :)
vBulletin® v3.6.4, Copyright ©2000-2025, Jelsoft Enterprises Ltd.