[JAVA] Successione calcoli su valori Double

[FinalFantasy]

ciao a tutti

forse questa la mia prima volta ke posto qui... all'uni sto studiando java e, prima ke iniziavo il corso, lo ritenevo un linguaggio inutile perché partivo dal concetto ke tutti i programmi interpretati siano inutil...

cmq...

volevo dirvi una cosa

perché se faccio una successione di calcoli, come

accumulatore+=1.0/(i*i)

se i arriva a 300, mi restituisce infinity?

intanto il numero di accumulatore è compreso tra 1 e 2...

cm mai?

ovviamente i è in un for ke va a 1 a n (n può essere anche 300)

è strano...xke io nn supero il limite dei numeri ke double può assumere, sn tra 1 e 2 ripeto...

[Andrea1979]

non è che fai partire i da 0?
PErchè in quel caso, la prima volta contatore diventa Infinity e tutte le altre iterazioni daranno infinity:

Queto va:

public class Counter {
  public static void main (String[] arg) {
    double contatore = 0;
    
    for (int i = 1; i < 400; i++) {
      contatore += 1.0/(i*i);
      System.out.println(contatore);
    }
  }
}

Questo invece restituisce Infinity

public class Counter {
  public static void main (String[] arg) {
    double contatore = 0;
    
    for (int i = 0; i < 400; i++) {
      contatore += 1.0/(i*i);
      System.out.println(contatore);
    }
  }
}

[FinalFantasy]

noo...
nn sn stupido
se faccio n iterazione, e la ennesima restituisce infinity, la n-1 mi restituisce un valora (nonché un'approssimazione a pi greco)
io ho fatto

double cont=0.0,pi;
final int n = 255;

for(int i=0;i<n;i++)
{
cont+=1.0/(i*i*i*i)
}

pi = cont * 90;
pi = Math.sqrt(Math.sqrt(pi));


se io n lo porto a 256, mi torna infinity

[Andrea1979]

Intanto quel codice a occhio nemmeno compila, visto che manca il ";" nell'istruzione all'interno del ciclo for. Poi lì i parte ancora da 0... e questi sono i risultati (ultimi 4) per cont con n = 256

1.0823231604936927
1.0823231554384698
1.082323147900007
1.0823231329112495

Il che è strano lo stesso, visto che il MAX_VALUE di un int è 2147483647 e che la sua radice quarta è circa 215 (a 216 i*i*i*i dovrebbe già dare problemi). Quindi ci sono altri problemi di fondo che si risolvono, sostanzialmente con

for (double i = 1; i < n; i++) {

lasciandomi comunque alquanto interdetto.

[david711]

In questo passaggio

1.0/(i*i*i*i);

i viene promossa a double nel momento in cui viene vista una divisione con un double (1.0/).

Se ad esempio fai

double cont=0.0,pi;
final int n = 255;
for(int i=0;i<n;i++)
{
cont+=1.0/(i*i*i*i);
System.out.println((i*i*i*i));
}
Escono ovviamente numeri negativi (Oltre MAX_VALUE)

Prova però a fare

double cont=0.0,pi;
final int n = 255;
for(int i=0;i<n;i++)
{
cont+=1.0/(i*i*i*i);
System.out.println((1.0*i*i*i*i));
}

Escono valori corretti nella notazione esponenziale.

Oppure

double cont=0.0,pi;
final int n = 255;
for(int i=0;i<n;i++)
{
cont+=1.0/(i*i*i*i);
System.out.println((1l*i*i*i*i*i));
}

Promosso a long

Per cui credo che in 1.0/(i*i*i*i); 1.0 promuova a double le "i"

CMQ per quel che riguarda il dubbio di infinity hai ragione basta porre i>0.

Ciao.

[Andrea1979]

public class Pi {
  public static void main (String[] args) {
    double cont=0.0,pi;
    final int n = 300;
    
    for (int i=1;i<n;i++) {
      cont+=1.0/(i*i*i*i);
      System.out.println(cont);
    }
    
    pi = cont * 90;
    pi = Math.sqrt(Math.sqrt(pi));
    System.out.println("Questo è PI: "+pi);

  }
}

Prova. Mi sa che la promozione a double avviene *dopo* la moltiplicazione nella parentesi.

Queste sono le uscite

1.0823231554384698
1.082323147900007
1.0823231329112495
Infinity
Infinity
...
...
Questo è PI: Infinity

Con jdk 1.4.x

[david711]

Prova a fare

System.out.println(-256*-256*-256*-256);

da 0 !!! (ed effettivamente se fai il calcolo in binario è vero !!)

da cui

1.0/0 =infinito

da cui tutto il resto


In sostanza quando i=256 , cont va all'infinito e quindi anche il resto.

[david711]

Mi spiego meglio.

Ovviamente intendevo dire che su 32 bit di un intero fa 0

-256 * -256* -256* -256=4294967296 in binario 100000000000000000000000000000000

ma troncando su 32 bit ottengo "0"

cont+=1.0/(0);
cont=infinito

...

pi=sqrt(sqrt(infinito)) = infinito