Newsgroup: it.comp.java
Titolo: Algoritmo alquanto seccante...

salve a tutti,
è da ieri che non riesco a creare un algoritmo che faccia la
seguente...
devo memorizzare in due array, che chiamo a1 e a2 dei dati, nel
seguente modo:
a1[0]=0.1 , a2[0]=0.1, a1[1]=0.2, a2[1]=0.1, a1[2]=0.2, a2[2]=0.2,
a1[3]=0.3 ... fino ad avere a1[...]=10, a2[..]=10
cioè quando m2[i]=m1[i] aumento m1, altrimenti deve aumentare solo m2.
Ho provato con cicli for, while e do-while, cicli varii annidati, ma
nulla da fare!!! Inoltre, dato che lo step (cioè 0.1) potrebbe essere
variabile, non so a priori la grandezza dei due array, per cui volevao
sapere se è posssibile allocare dinamicamente gli array, o cmq nn
definirne le dimensioni.
Qualcuno ha dei suggerimenti???

Angela ha scritto:

Un array di cui non conosci a priori la dimensione in java si chiama Vector. E' 
un oggetto del package java.util, leggi il javadoc qui
http://java.sun.com/j2se/1.5.0/docs/api/
I metodi sono tutti self-explanatory, sicuramente non avrai difficolta' ad usare 
questa struttura dati che cmq ricalca quella di un array, si "ridimensiona" 
automaticamente permettendoti di inserire e togliere elementi in qualunque 
posizione.
Non capisco come mai hai difficolta' con l'algoritmo, dato che lo hai scritto!
 > cioè quando m2[i]=m1[i] aumento m1, altrimenti deve aumentare solo m2.
Vector v1 = new Vector();
Vector v2 = new Vector();
float step = ?;
float m1 = step, m2 = step;
for(int i = 0; m1 != 10 || m2 != 10; i++) {
	v1.add(i, m1);
	v2.add(i, m2);
	if(v1.get(i) == v2.get(i))
		m1+=step;
	else
		m2+=step;
}
O qlcs di simile.
Miao
Co

 Vector.
Un piccolo appunto: Vector e' synchronized, se non prevedi piu' threads 
che ci accedino e' meglio usare ArrayList.
-- 
Giambo - Occhio al filtro antispam _e_ alla whitelist !

 
Vero vero

Inanzitutto grazie a tutti per il suggerimento, sono andata a guardare,
non sapevo neppure dell'esistenza di Vector, avevo solo letto di
ArrayList...
Ho dovuto modificare un pò l'algoritmo perchè quando provavo a
scrivere step=0.1 eclipse mi dice subito che devo scriverlo come double
e che vector va parametrizzato. Quindi ho fatto la seguente:
Vector<Double> v1 = new Vector<Double>();
	    Vector<Double> v2 = new Vector<Double>();
	    double step = 0.1;
	    double m1 = step;
		double m2 = step;
	    for(int i = 0; m1 != 10 || m2 != 10; i++) {
	            v1.add(i, m1);
	            v2.add(i, m2);
	            if(v1.get(i) == v2.get(i))
	                    m1+=step;
	            else
	                    m2+=step;
	    }
Tuttavia, anche in questo modo non va bene. Infatti sono andata a
guardare col debug cosa fa e anzichè aumentare v1 aumenta v2 (cioè vi
rimane semore a 0.1 a parte il secondo elemento mi pare). Inoltre, da
un certo numero in poi, comincia a sballare pure lo step, cioè
anzichè 0.3 mi dà 0.30000000000000004 e la cosa peggiora andando
avanti. Può essere un problema di Vector?? E se invece mi limito a
usare l'array ( al limite la dimensione max la calcolo di volta in
volta facendo 10/step) come andrebbe modificato? magari viene 1000
volte più semplice. Ci sto perdendo la salute...
Un'altra cosa... scusando la mia ignoranza in materia.... qualcuno ha
parlato di usare arraylist invece di vector... Ho sbirciato qua e là e
mi pare che la sintassi sia simile, ma non sono riuscita ancora a
capire cos'è che cambia!!! Forse non ho ben chiaro il concetto di
threads...

 writes:
A> Vector<Double> v1 = new Vector<Double>();
A> 	    Vector<Double> v2 = new Vector<Double>();
A> 	    double step = 0.1;
A> 	    double m1 = step;
A> 		double m2 = step;
A> 
A> 	    for(int i = 0; m1 != 10 || m2 != 10; i++) {
A> 	            v1.add(i, m1);
A> 	            v2.add(i, m2);
A> 	            if(v1.get(i) == v2.get(i))
A> 	                    m1+=step;
A> 	            else
A> 	                    m2+=step;
A> 
A> 	    }
A> Tuttavia, anche in questo modo non va bene. Infatti sono andata a
A> guardare col debug cosa fa e anzichè aumentare v1 aumenta v2 (cioè
A> vi rimane semore a 0.1 a parte il secondo elemento mi
A> pare). Inoltre, da un certo numero in poi, comincia a sballare pure
A> lo step, cioè anzichè 0.3 mi dà 0.30000000000000004 e la cosa
A> peggiora andando avanti.
Al tempo, che codice esegui ?
v1 è  un array dinamico, una volta  che hai impostato il  valore di un
elemento non vedo codice che lo modifichi.
Poi come fa step a valere  0.3 (con o senza gli errori di rappresenta-
zione) ?
A> Può essere un problema di Vector??
No.
Il problema a  naso è il solito dell'uso dei  numeri in virgola mobile
che per gli ignari riserva alcune trappole.
Ad esempio, per  te 0.1 è un valore semplice  da rappresentare, per la
macchina (usando float e double) è un numero periodico.
Hai provato ad  usare i BigDecimal usando per  step il costruttore che
accetta un parametro di tipo String ?
A>  E se
A> invece mi limito a usare l'array ( al limite la dimensione max la
A> calcolo di volta in volta facendo 10/step) come andrebbe
A> modificato? magari viene 1000 volte più semplice.
Ma nemmeno per sogno diviene  più semplice, per cominciare devi sapere
a priori la dimensione dell'array...
A> Un'altra cosa... scusando la mia ignoranza in materia.... qualcuno
A> ha parlato di usare arraylist invece di vector... Ho sbirciato qua
A> e là e mi pare che la sintassi sia simile, ma non sono riuscita
A> ancora a capire cos'è che cambia!!! Forse non ho ben chiaro il
A> concetto di threads...
Un thread è un flusso di esecuzione delle istruzioni di un programma.
Uno stesso codice  può essere eseguito da più  thread. Cosa succede in
questo caso  ? Che  i due thread  possono pestarsi  i piedi e,  se non
seguono certe regole, rovinare tutte le strutture dati.
Ti faccio  un esempio fisico.  Abe e  Bill (A e B)  lavorano alla Acme
Fruits,  devono preparare  una pila  di cassette  di frutta  in questo
modo:  mettono una cassetta  vuota sulla  pila e  poi la  riempiono di
frutta. Abe e Bill non sono dei geni, come vedrai.
Arriva primo Abe, prende una cassetta vuota e la mette sulla pila, poi
se ne va a prendere le arance.
Arriva Bill, prende  una cassetta vuota e siccome  si è portato dietro
le banane, le mette nella cassetta.
Torna Abe  con le arance, vede la  cassetta in cima piena  e prende la
grandiosa decisione di svuotarla per metterci le sue arance, le banane
vanno perdute e c'è sulla pila una cassetta vuota.
Soluzione:  il  caporeparto  dice ad  Abe  e  a  Bill di  piazzare  un
segnalino  sulla cassetta  vuota, e  di toglierlo  quando  la cassetta
viene riempita.  Quando c'è un segnalino dell'altro  lavoratore non si
può lavorare sulla pila.
La storia  di prima  cambia, perchè Bill,  visto il segnalino  di Abe,
aspetta che  questi abbia  messo le arance  nella cassetta e  tolto il
segnalino prima di mettere le sue banane.
Un ArrayList si  comporta come nel caso senza  segnalini (ovvero lock)
in quanto è priva di  meccanismi di sincronizzazione, Vector invece li
ha e  si comporta  come nel  caso coi segnalini  (il lock  viene messo
all'inizio delle operazioni di ogni metodo e tolto alla fine)
O.K.  questa la favola.  Leggersi un  buon libro  per la  storia vera,
peraltro non semplicissima.
Non  si impara a  programmare senza  programmare. Ma  non si  impara a
programmare senza leggere la documentazione.
-- 
 /\           ___
/___/\_|_|\_|__|___Gian Uberto Lauri_____
  //--\| | \|  |   Integralista GNUslamico
\/                 e coltivatore diretto di Software

 programmare senza leggere la documentazione.
Lo so...lo so :'-(
Invece mi è successa una cosa strana in running(prima avevo solo
provato il dedug passo passo)... mi compare l'errore:
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
e questa come si risolve???

 
Probabilmente perche' quel ciclo non finisce mai, continui a creare elementi, 
all'infinito e prima o poi finisce la memoria. Ehi, guarda che il mio codice non 
lo devi copiaincollare nella tua applicazione. E' una traccia, sicuramente devi 
controllare la condizione di uscita e fare cmq dei controlli sul valore di m1 e m2.

 controllare la condizione di uscita e fare cmq dei controlli sul valore di m1 e m2.
Lo so, stavo infatti provando a modificarlo, soprattutto all'inizio...
però col debug ho visto subito che qualcosa non andava perchè
incrementa  solo v2 e non v1, o meglio non lo fa come voglio io.
Inoltre al momento sto cercando di risolvere il problema
dell'approssimazione con BigDecimal, ma non riesco a trovare in rete un
esempio pratico coi numeri. Ti ringrazio cmq per l'algoritmo, ma ci
sarà ancora moooolto da lavorare.

> mobile che per gli ignari riserva alcune trappole.
A> sono una di questi... :-(
L'unica soluzione è nella documentazione purtroppo....
 
Non dico un corso di analisi numerica, ma un qualcosa che renda consci
dei problemi.
A> Invece mi è successa una cosa strana in running(prima avevo solo
A> provato il dedug passo passo)... mi compare l'errore:
A> Exception in thread "main" java.lang.OutOfMemoryError: Java heap
A> space
Stranamente il problema dovrebbe risolversi coi BigDecimal :)
Come ipotizzava Corrado vai in un loop infinito.
L'espressione booleana
               m1 != 10 || m2 != 10
vale  false se  e solo  se m1  e m2  sono ambedue  diversi da  10 (tra
parentesi, il 10  -che è un int- viene promosso a  double.  Ora se per
"caso"  va a  finire  che una  tra  m1 o  m2  vale 10  più  o meno  un
qualcosina  il  test  non  sarà  mai  falso e  il  loop  andrà  avanti
(teoricamente) all'infinito (in pratica  finisci la memoria a furia di
aggiungere elementi al vector). E siccome tu hai uno step che non vale
esattamente 0.1, allora la somma  di 100 step sarà qualcosa di diverso
da 10: hai  già visto comparire un valore che  era qualcosa di diverso
da un 3.0 .


 writes:
A> Corrado Alesso ha scritto:
A>  Inoltre al momento sto cercando di risolvere il
A> problema dell'approssimazione con BigDecimal, ma non riesco a
A> trovare in rete un esempio pratico coi numeri.
http://java.sun.com/j2se/1.4.2/docs/api/
...
BigDecimal zeroPuntoUno = new BigDecimal("0.1");
BigDecimal totale = zeroPuntoUno.clone();
for(int i=0; i < 99; i++) {
   totale.add(zeroPuntoUno);
   System.out.println(totale.toString());
}
...


Ho scritto qualcosa del genere anche non ho ancora capito come
modificare bene il for visto che così mi dà errore nella sua riga:
Vector<BigDecimal> v1 = new Vector<BigDecimal>();
Vector<BigDecimal> v2 = new Vector<BigDecimal>();
BigDecimal step = BigDecimal.valueOf(0.1);
BigDecimal m1 = step, m2 = step;
for(int i = 0; m1.compareTo(10)<0 || m2.compareTo(10))<0; i++) {
          v1.add(i, m1);
          v2.add(i, m2);
          if(v1.get(i) == v2.get(i))
                m1=m1.add(step);
          else
               	m2=m2.add(step);
        }
for (int i=0; i<v1.size(); i++) {
   System.out.printf("%.15e    %.15e   %.15e ",i,v1.get(i),v2.get(i));
   }
Evidentemente non uso correttamente compareTo...
Inoltre, se uso string come dici tu, posso ancora usare il mio numero
per fare i calcoli o solo per stamparlo correttamente? A me interessano
entrambe ma così mi sembra che lo converta in string o ho capito male?

 Evidentemente non uso correttamente compareTo...
con i bigdecimal non so come fare, ma con i float (o i double) di
solito si fa (esempio con l'if, ma e' uguale col for):
double epsioln = 0.0000001;  //epsilon variabile a piacere, a
dipendenza della precisione che si vuole
if( numero - 10.0 < epsilon)
{
}
ma se hai solo valori a virgola fissa decisamente e' meglio i
bigdecimal, oppure se usi solo una cifra dopo la virgola puoi sempre
fare un *10, e quindi fare tutti i calcoli con gli interi, e poi fare
diviso 10 quando visualizzi (/me programma DSP :P)
Ciao Jack

Se ora scrivo:
...
BigDecimal step = BigDecimal.valueOf(0.1);
BigDecimal m1 = step, m2 = step;
BigDecimal max = BigDecimal.valueOf(10);
for(int i = 0; m1.compareTo(max)!=0 || m2.compareTo(max)!=0; i++) {
...
adesso eclipse nn segra più errore ma comapre sempre:
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
Inoltre, quando controllo col debug il valore di step compare questo:
intCompact	1
intVal	null	
precision	1	
scale	1	
stringCache	null	
ma 0.1 dov'è?

    }
C'e' una parentesi che non c'entra nulla.
for(int i = 0; m1.compareTo(10)<0 || m2.compareTo(10)<0; i++) {
cosi' va meglio


Ho provato anche così, pure togliendo la parentesi sospetta, ma il
modo migliore è come avevo scritto sopra, anche se gli Orrori
rimangono...

 writes:
A> Se ora scrivo: ...  BigDecimal step = BigDecimal.valueOf(0.1);
A> BigDecimal m1 = step, m2 = step; BigDecimal max =
A> BigDecimal.valueOf(10);
A> for(int i = 0; m1.compareTo(max)!=0 || m2.compareTo(max)!=0; i++) {
A> ...
Azz, mi  sa che si č  perso un mio post,  forse per la  presenza di un
attachment.
O.K. ci riprovo, leggere con caratteri monospaced per favore :)
Alua, a mio parere gli errorini che ci sarebbero qui:
1) Hai inizializzato  male step.  Usare un valore  double per generare
   un BigDecimal puň  dare problemi in quanto non  passi il valore che
   hai  scritto  nel sorgente,  ma  la  sua rappresentazione  binaria,
   meglio usare  il costruttore che accetta  gli String (e  no, non ci
   sono  problemi ad  usare un  BigDecimal costruito  partendo  da uno
   String. Di nuovo, sommando 100  volte step ad un diverso BigDecimal
   inizializzato a 0 ti troveresti in mano qualcosa di diverso da 10.
2) Hai inizializzato male m1 e m2, creando un problema di aliasing.
   Il  tuo codice  genera  questa situazione  in  cui tutte  e tre  le
   variabili fanno riferimento allo stesso oggetto:
                   step ----------------->[BigDecimal: 0.1]
                   m1   -------------------^ ^
                   m2   ---------------------+
   Il motivo  sta nel fatto che  le variabili di  tipo oggetto (ovvero
   non  byte, char,  short, int,  long, float,  double e  boolean) non
   contengono  valori  (oggetti)   ma  riferimenti  agli  stessi.   Il
   riferimento  č la  cosa  che  ti permette  di  pescare nel  mucchio
   proprio quell'oggetto cosě come una ricevuta della lavanderia (o un
   puntatore :) ).
   Quandio  assegni il  valore di  una  variabile di  tipo oggetto  ad
   un'altra non copi l'oggetto ma il riferimento.
   Per  copiare l'oggetto  devi creare  un nuovo  oggetto  identico al
   precedente (un  clone, da  cui il metodo  clone()) ed  assegnare il
   riferimento a questo nuovo oggetto.
A> adesso eclipse nn segra piů errore ma comapre sempre:
A> Exception in thread "main" java.lang.OutOfMemoryError: Java heap
A> space
Non č che ti trovi step che comincia a valere
 0.1
 0.2
 0.4
 0.8
 1.6
 3.2
 6.4
12.8
A> Inoltre, quando controllo col debug il valore di step compare
A> questo:
A> intCompact 1 intVal null precision 1 scale 1 stringCache null
A> ma 0.1 dov'č?
Non č memorizzato in questo modo.
La hai letta  la documentazione della classe BigDecimal  ? Prima leggi
la documentazione per favore, che c'č scritto come viene conservato il
valore.
Per vederne chiaramente il valore usa il metodo toString().


Avevo inanzitutto trovato un errore di logica, ed ho dovuto inserire un
altro if (per ora lo scrivo col double, in attesa di capire come
funziona bigdecimal):
for(int i = 0; m2 >= 10; i++) {
                v1.add(i, m1);
                v2.add(i, m2);
                if( m1==m2 ) m2=step;
                if(v1.get(i) == v2.get(i))
                        m1+=step;
                else
                        m2+=step;
        }
ma dal secondo if mi dà già problemi,anche se ho controllato e il
primo elemento è per entrambi uguale. Può essere sempre una questione
di approssimazione? Inoltre, se provo a stampare i risultati non esce
nulla, nè su schermo nè su file, come se tutti gli elementi fossero
nulli, o meglio... appena esco dal ciclo lo sono... cosa succede?

 writes:
A> v1.add(i, m1); v2.add(i, m2);
Attenzione, la  add non clona l'oggetto, aggiunge  solo un riferimento
all'oggetto.
A>                 if( m1==m2 ) m2=step;
Attenzione, questa è vera se e  solo se m1 e m2 contengono riferimenti
al medesimo  oggetto. Per testare  l'uguaglianza "dello stato"  di due
oggetti come  qui serve a  te (verificare che il  valore immagazzinato
sia lo  stesso) si usa equals() -  o compareTo() se l'oggetto  è di un
tipo che implementa Comparable.
Scusa la crudezza,  ma ti consiglio vivamente di  tornare ai manuali e
di rileggerli con attenzione.
A>                 if(v1.get(i) == v2.get(i)) m1+=step; else m2+=step;
Idem come sopra.
E  per  ora NON  usare  gli  operatori, usa  i  metodi,  anche per  le
comparazioni.


 comparazioni.
Ho provato a cambiare qualcosina(cioè a seguire il consiglio di Jack,
che non era troppo malvagio) e, a meno della solita approssimazione,
l'algoritmo adesso funziona:
Vector<Double> v1 = new Vector<Double>();
Vector<Double> v2 = new Vector<Double>();
double step = 0.1;
double m1 = step;
double m2 = step;
double mmax=10;
for(int i = 0; m2<mmax; i++) {
           v1.add(i, m1);
           v2.add(i, m2);
           if( Math.abs(m1-m2) < 0.00001 ) m2=step;
           if(Math.abs(v1.get(i)- v2.get(i))<0.00001)
                        m1+=step;
             else
                        m2+=step;
        }
Dovrebbe essere modificato solo double in bigdecimal, ma al momento la
cosa mi risulta parecchio ostica(l'ultimo valore che mi dà è
10.09999999999998 anzichè 10). Ti ringrazio cmq per tutti i
suggerimenti, ma questa cosa la devo far veder domani al mio prof,
quindi meglio così che non funzionante. Non sono un'informatica,
quindi imparare ex novo un linguaggio di programmazione tanto
complesso(non avevo mai fatto programmazione a oggetti) , insieme alle
mille altre cose che una studentessa fa oltre la tesi(tipo studiare)
non è proprio semplice. Spero di non avervi fatto troppo irritare...

> comparazioni.
A> Ho  provato a cambiare  qualcosina(cioè a  seguire il  consiglio di
A> Jack,  che  non  era  troppo  malvagio)  e,  a  meno  della  solita
A> approssimazione, l'algoritmo adesso funziona:
Il consiglio  di Jack  era buono, non  "non era troppo  malvagio". Coi
floating  point  non  hai  molte  altre  strade  se  non  definire  un
intervallo all'interno dei quali considerare uguali due valori.
A> Ti ringrazio cmq  per tutti i suggerimenti, ma  questa cosa la devo
A> far  veder  domani  al  mio   prof,  quindi  meglio  così  che  non
A> funzionante.
Se si lamenta mandalo a seguire un corso di analisi numerica.
A> Non sono un'informatica,
A> quindi imparare ex novo un linguaggio di programmazione tanto
A> complesso(non avevo mai fatto programmazione a oggetti)
Non c'è solo quello, Java è un finto facile.
A> alle mille  altre cose  che una studentessa  fa oltre  la tesi(tipo
A> studiare) non è proprio semplice.  Spero di non avervi fatto troppo
A> irritare...
La tesi qui dentro la hanno fatta in diversi... No, non è semplice, ma
le cose che di devono fare vanno fatte.


 le cose che di devono fare vanno fatte.
Lo so bene...non era un modo per giustificarmi...
ciao ciao

> per m1 e m2.
A> quindi non andrà sicuramente bene come ho scritto di seguito:
A>       Vector<BigDecimal> v1 = new Vector<BigDecimal>();
A>       Vector<BigDecimal> v2 = new Vector<BigDecimal>();
A>       BigDecimal step = new BigDecimal("0.1");
         // Dovrebbe funzionare, ma istanziare due oggetti sarebbe stato 
         // a parer mio piu` pulito
A>       BigDecimal m1 = step;
A>       BigDecimal m2 = step;
A>       BigDecimal max= new BigDecimal("10");
         // Questo ciclo non verrà mai attraversato! :)
         // for {} ha la stessa semantica di while {}, ovvero si cila
         // MENTRE la condizione è vera... 10 a uno che volevi
         // scrivere m2 != 0
 
A>       for(int i = 0; m2.compareTo(max)==0; i++) {
A>              v1.add(i, m1);
A>              v2.add(i, m2);
A>              if(m1.compareTo(m2)==0) m2=step;
A>              if(v1.get(i).compareTo(v2.get(i))==0)
A>                      m1=m1.add(step);
A>              else
A>                      m2=m2.add(step);
A>      }
A> Putroppo mi esce subito fuori dal ciclo e non capisco perchè...
Vedi sopra. Non ti faccio storie perché stai facendo la tesi :)
(scherzo, sono errori di battitura che capitano).
A> ma come diavolo si deve usare il valore assoluto con BigDecimal? Volevo
A> fare una cosa analoga a prima ma è impossibile!! Mi compaiono
A> 1000000 errori... E' accettabile la soluzione sopra?Dove sbaglio?
I BigDecimal hanno il loro metodo abs() per il valore assoluto, ma non
ti serve  in questo caso, in quanto  con quelli non hai  i problemi di
precisione dei float e dei double.
BTW, in che ti laurei ?


 BTW, in che ti laurei ?
Fisica...se m i finisco le materie :-)

> BTW, in che ti laurei ?
A> Fisica...se m i finisco le materie :-)
Ti  consiglio  di studiarti  un  po'  di  calcolo numerico  se  rimani
nell'ambiente...
(Strano che ti abbiano fatto fare Java e non FORTRAN :) )


 (Strano che ti abbiano fatto fare Java e non FORTRAN :) )
Infatti avevo fatto solo Fortran finora, ma per forza di cose(storia
troppo lunga da spiegare) devo usare java..immagina il trauma del
passaggio...

> (Strano che ti abbiano fatto fare Java e non FORTRAN :) )
A> Infatti avevo fatto solo Fortran finora, ma per forza di
A> cose(storia troppo lunga da spiegare) devo usare java..immagina il
A> trauma del passaggio...
Azz, passare direttamente dal linguaggio  più primitivo ad uno dei più
recenti... E` un bel salto.


 recenti... E` un bel salto.
o imparo java o non faccio la tesi, immagina che ci sto dietro da
giugno e nn ho ancora imparato molto(anche se nei forum trovo in genere
moltissime informazioni). Il mio relatore  però mi ha sconsigliato di
usare troppi confronti visto che questo sarà uno degli algortitmi più
semplici, quindi è meglio nn sovracccaricare troppo la cpu!
Un'alternativa forse sarebbe usare due cicli for così(ma non sono
sicura del risultato, visto che era una delle prime idee che mi era
venuta):
for (int i=0;i<99, i++)
{
m1(i)=step*(i+1);
for (j=0, j<i,j++)
{
m2(j)=m1(i)
}
}
ho supposto di avere dei semplici array double... Come si potrebbe
migliorare una cosa del genere? In relata è come se dovessi creare una
griglia da 0.1 a 10 con passo 0.1, cioè non mi interessano le coppie
di valori uguali. Con quest'ultimo algoritmo però m1 sarà di
dimensione 100 e m2 sarà (1+2+3..+100), o no?

cioè non mi interessano le coppie  di valori uguali.
volevo dire con valori ripetuti

 writes:
A> Il mio relatore però mi ha
A> sconsigliato di usare troppi confronti visto che questo sarà uno
A> degli algortitmi più semplici, quindi è meglio nn sovracccaricare
A> troppo la cpu!
I cicli  richiedono confronti. Verissimo  che oramai anche i confronti
tra float o double costano quanto un confronto tra interi, ma quando
sono tanti...
Tornando al  problema originale che  se non erro  era di avere  in due
array questa disposizione di valori
idx     v1      v2
----    ----    ----
0        0.1     0.1
1        0.2     0.1
2        0.2     0.2
3        0.3     0.2
4        0.3     0.3
5        0.4     0.3
6        0.4     0.4
fino ad avere in fondo agli array, all'indice max (che dovrebbe essere
di 398 elementi, ma non fidarti delle mie capacità aritmetiche :) ):
max     10.0    10.0 
dovresti potertela cavare con un ciclo solo, srotolando quello interno.
double step=0.1;
v1[0]=0.1; // array di double di max+1 elementi
v2[0]=0.1; // array di double di max+1 elementi
for(int idx = 2; idx < (max+1) {
  double tmp2 = v1[idx-2];
  double tmp1 = v1[idx-2]+step;
  v1[idx-1] = tmp1;
  v1[idx] = tmp1;
  v2[idx-1] = tmp2;
  v2[idx] = tmp1;
}  
// NON TESTATO!!!! Scritto di getto e non provato...



Effettivamente ho fatto un calcolo... se si considerano le coppie, per
un indice che va da 0 a 100 (100=10/0.1), che nn abbiano indici
ripetuti, gli elementi sono invece 5050!!!  Ora che so quant'è l'array
nn ho più bisogno di usare vector( perchè appesantire tutto
inutilmente?), però il tuo algoritmo si vede che è errato(e cmq lo
anche provato), secondo me il ciclo di sopra andrebbe modificato
mettendo come max anzichè 99--> 5050 e creando una condizione che
anzichè far salire m1 tantissimo, appena arriva a 10 farlo
ricominciare da 0.1 e così via fino alla fine. In questo modo forse ho
solo 2 for e un if. Al momento nn ho tempo di farlo, ma come idea
com'è?

> interi, ma quando sono tanti...
A> Se ce n'č uno solo potrebbe anche andare bene, ma se diventano 3
A> per ciclo non si appesantisce un pň troppo?
Si chiama  srotolamento dei  cicli e  viene fatto da  molti tra  i piů
moderni compilatori C/C++.
A>  Poi mi sono chiesta, ma
A> nn so la risposta, se č peggio un for in piů o uno o due confronti
A> in piů....
A  paritŕ di  peso  del  confronto, hanno  lo  stesso peso.   Chiamare
equals() o  compareTo() pesa  molto di  piů che fare  un test  con gli
operatori.
A> Effettivamente ho fatto un calcolo... se si considerano le coppie, per
A> un indice che va da 0 a 100 (100=10/0.1), che nn abbiano indici
A> ripetuti, gli elementi sono invece 5050!!!
Mi sa che non ho capito bene quale č il tuo problema...
A> l'array nn ho piů bisogno di usare vector( perchč appesantire tutto
A> inutilmente?), perň il tuo algoritmo si vede che č errato(e cmq lo
A> anche provato)
Ho detto che non  c'era da fidarsi, era una cosa buttata  lě. Ma mi sa
tanto di aver  scritto una cosina che risolve  un problema diverso dal
tuo.
Attansiun che se si chiede aiuto male si avrŕ un aiuto sbagliato :) :).



certo se nn avevi capito il problema... è lo stesso del primo topic,
volevo solo scriverlo con meno if (che poi contengono compare)
possibili, cioè ottimizzarlo.
Ma tu cosa sei: un informatico, un ingegnere o un semplice appassionato?

 writes:
A> Ma tu cosa sei: un informatico, un ingegnere o un semplice
A> appassionato?
Tutte e tre le cose.
