[Java] Applet Telt niet bij elkaar op

[zero_cool89]

ok, ik ben bezig aan een applet die pi berekend met de taylor reeks. (-1)^n / (2*n+1)

maar hij telt de n niet bij elkaar op. Ik heb google al geprobeerd maar daar kon ik niets vinden.
Ik zoek geen kant en klare oplossing maar misschien een klein duwtje in de goede richting.

dit is de code die ik tot nu toe heb:

code:

void button1_ActionPerformed(java.awt.event.ActionEvent event)
    {
        
        int termen;
               termen = Integer.parseInt
               (invoerVeld.getText());
  
        int abtermen;
          if (termen > 0) abtermen = termen; else abtermen = -termen; // zorgt dat het een absoluut getal is.
        double Pi = 0;
  
        do          
        {
            if (abtermen % 2 == 0) // kijkt of het een even getal is.
            {           
               Pi = 1 / ( 2 * abtermen + 1 );
               
            }
            else 
            {
               Pi = -1 / ( 2 * abtermen + 1 );
            }
            abtermen = abtermen - 1;
            Pi = Pi + Pi;
        }
     while (abtermen >= 0);
     uitvoerVeld.setText(String.valueOf(Pi));

    

             
    }

hier is de applet:

http://members.chello.nl/h.jansenvgaalen/JApplet1.java

ik hoop dat het gewoon een dom foutje is. maar hij telt de oude Pi niet bij de nieuwe Pi op

[Plecky]

Is inderdaad een dom foutje . Je overschrijft Pi in regel 16 of 21 met een nieuwe waarde, in regel 24 verdubbel je dan Pi weer. (en dat herhaalt zich steeds tijdens de loop)
Je kan op regel 16 en 21 beter een tijdelijke variable gebruiken i.p.v. Pi hergebruiken.

[ Voor 9% gewijzigd door Plecky op 24-01-2007 12:52 ]

[zero_cool89]

ja dat is inderdaad beter , maar nu geeft hij elke keer dat ik een ander getal invoert de zelfde uitkomst. (namelijk 1.0)

Het is de bedoeling dat als iemand 6 invult dat de applet de uitkomst voor 6, 5,4,3,2,1,0 bij elkaar optelt.

dit heb ik nu met hulp van Plecky:

code:

    void button1_ActionPerformed(java.awt.event.ActionEvent event)
    {
        
        int termen;
               termen = Integer.parseInt
               (invoerVeld.getText());
  
        int abtermen;
          if (termen > 0) abtermen = termen; else abtermen = -termen; // zorgt dat het een absoluut getal is.
        double Pi = 0;
        double x = 0;
        
  
        do          
        {
            if (abtermen % 2 == 0) // kijkt of het een even getal is.
            {           
               x = 1 / ( 2 * abtermen + 1 );
               
            }
            else 
            {
               x = -1 / ( 2 * abtermen + 1 );
            }
            abtermen = abtermen - 1;
            Pi = x + Pi;
         }
     while (abtermen >= 0);
     uitvoerVeld.setText(String.valueOf(Pi));

    

             
    }

[Creepy]

Prima, en nu mogen wij het voor je fixen? Zo werkt het hier niet

Wat heb je nu zelf al geprobeerd om het voor elkaar te krijgen? En wat werkt er nu wel en wat werkt er nu niet? Zie ookProgramming Beleid en dan met name Programming Beleid - De Quickstart

[zero_cool89]

Creepy schreef op woensdag 24 januari 2007 @ 13:14:
Prima, en nu mogen wij het voor je fixen? Zo werkt het hier niet

Wat heb je nu zelf al geprobeerd om het voor elkaar te krijgen? En wat werkt er nu wel en wat werkt er nu niet? Zie ookProgramming Beleid en dan met name Programming Beleid - De Quickstart

ik zoek geen kant en klare oplossing , maar ik heb niet veel ervaring met java en ik vroeg mij af of iemand mij in de goede richting kon helpen, met een post als Plecky kom ik al veel verder zonder dat het kant en klaar gepresenteerd werd.

Wat ik zelf heb geprobeerd:

Googlen/ een andere loop gebruiken (met zelfde effect) / in plaats van if / else, ( -1 ) ^ abtermen gebruikt maar dat werkte helemaal niet.

Wat er wel werkt:

hij herhaalt de code tot hij op 0 komt en geeft de uitkomst, dit is altijd 1.0 (1/1 = 1). Maar de loop telt niet de voorgaande uitkomst van bijvoorbeeld 1 (-1/3 = -3) op bij de uitkomst van 0.

EDIT:
ik dacht dat ik misschien vanaf 0 moest beginnen en de loop moest herhalen tot het het ingevoerde getal was, maar de uitkomst blijft 1.0

code:

void button1_ActionPerformed(java.awt.event.ActionEvent event)
    {
        
        int termen;
               termen = Integer.parseInt
               (invoerVeld.getText());
  
        int abtermen;
          if (termen > 0) abtermen = termen; else abtermen = -termen; // zorgt dat het een absoluut getal is.
        double Pi = 0;
        double x = 0;
        int y;
        y = 0;
  
        do          
        {
            if (y % 2 == 0) // kijkt of het een even getal is.
            {           
               x = 1 / ( 2 * y + 1 );
               
            }
            else 
            {
               x = -1 / ( 2 * y + 1 );
            }
            y++;
            Pi = x + Pi;
         }
     while (y != abtermen);
     uitvoerVeld.setText(String.valueOf(Pi));

    

             
    }

ik dacht dat het misschien met de break code zou lukken, maar weer was de uitkomst altijd 1.0:

code:

    void button1_ActionPerformed(java.awt.event.ActionEvent event)
    {
        
        int termen;
               termen = Integer.parseInt
               (invoerVeld.getText());
  
        int abtermen;
          if (termen > 0) abtermen = termen; else abtermen = -termen; // zorgt dat het een absoluut getal is.
        double Pi = 0;
        double x = 0;
        int y;
        y = 0;
  
        do          
        {
            if (y == abtermen) 
            break;
            
            else
            {
            
            if (y % 2 == 0) // kijkt of het een even getal is.
            {           
               x = 1 / ( 2 * y + 1 );
               
            }
            else 
            {
               x = -1 / ( 2 * y + 1 );
            }
            y ++;
            Pi = x + Pi;
            }
         }
     while (y != abtermen);
     uitvoerVeld.setText(String.valueOf(Pi));

    

             
    }

[ Voor 50% gewijzigd door zero_cool89 op 24-01-2007 13:43 ]

[hammerhead]

zit het probleem niet in het feit dat je een integer deling doet?

1 is integer
2*y+1 is ook integer
als je 1.0/(2*y+1) van maakt, werkt het dan niet?

[Jochem Knoops]

hammerhead schreef op woensdag 24 januari 2007 @ 13:39:
zit het probleem niet in het feit dat je een integer deling doet?

1 is integer
2*y+1 is ook integer
als je 1.0/(2*y+1) van maakt, werkt het dan niet?

Dan wordt er in dit geval netjes een double van gemaakt.

Ik heb je code bekeken en ik kan uit de code nog niet eens halen wat je eigenlijk wilt dat eht programma moet doen volgens jou. daarnaast vind ik je OP ook neit echt duidelijk.
Kan je misschien met woorden aangeven wat je verwacht en evt ook een tabel met waardes met voorbeeld wat je als output verwacht bij welke input.

[zero_cool89]

hammerhead schreef op woensdag 24 januari 2007 @ 13:39:
zit het probleem niet in het feit dat je een integer deling doet?

1 is integer
2*y+1 is ook integer
als je 1.0/(2*y+1) van maakt, werkt het dan niet?

hey bedankt, hij doet nu iets, hij geeft getallen. dit is mooi bedankt man ik moet hier nog even mee doorgaan en dan werkt hij misschien, ik post wel hoe het gaat

EDIT:

hij werkt nu perfect, een leuke manier om pi te berekenen. Ik wil graag iedereen bedanken die hier tijd aan heeft besteed, dit kan gesloten worden.

Nu moet ik alleen alles nog even opschonen een mooi maken

hier het resultaat: (ik was *4 vergeten)

code:

    void button1_ActionPerformed(java.awt.event.ActionEvent event)
    {
        
        int termen;
               termen = Integer.parseInt
               (invoerVeld.getText());
  
        int abtermen;
          if (termen > 0) abtermen = termen; else abtermen = -termen; // zorgt dat het een absoluut getal is.
        double Pi = 0;
        double x = 0;
        double q = 0;
        int y;
        
        y = 0;
  
        do          
        {
            if (y == abtermen) 
            break;
            
            else
            {
            
            if (y % 2 == 0) // kijkt of het een even getal is.
            {           
               x = 1.0/(2*y+1);
               
            }
            else 
            {
               x = -1.0/(2*y+1);
            }
            y = y + 1;
            q = x + q;
            Pi = q * 4;
            }
         }
     while (y != abtermen);
     uitvoerVeld.setText(String.valueOf(Pi));

    

             
    }
}

[ Voor 59% gewijzigd door zero_cool89 op 24-01-2007 13:50 ]

[Robtimus]

Even een lesje integer rekenen.

Laten we x = 1 / ( 2 * y + 1 ) eens uitsplitsen.

y is een integer.
Daarom is 2 * y een integer.
Daarom is 2 * y + 1 een integer.
1 is een integer.

Als je een integer deelt door een integer komt daaruit, verrassing, een integer! Namelijk de div (ofwel het wiskundige resultaat naar beneden afgerond). Als voorbeeld, 3 / 2 = 1.

Dat jij daarna deze integer aan een double assigned maakt niets uit, het is in principe nog steeds een geheel getal, alleen nu als double.


De oplossing hiervoor is simpel: zorg ervoor dat 1 van beide operands van je deling een double of float is. Dat kan door expliciet casten x = 1 / ( 2 * (double)y + 1 ), of als je met constanten werkt gewoon een .0 erbij zetten: x = 1.0 / ( 2 * y + 1 ).


Als samenvatting een stelregel:
Het type van het resultaat van een wiskundige operatie is:
- een double als minimaal 1 van de operands een double is
- anders een float als minimaal 1 van de operands een float is
- anders een long als minimaal 1 van de operands een long is
- anders een integer

Dus ook:

Java:

byte b1 = 0;
byte b2 = 1;
byte b3 = b1 + b2; // compile error: b1 + b2 levert een integer!

edit:
Wat hammerhead dus in een paar regels al zei...

[Jochem Knoops]

IceManX schreef op woensdag 24 januari 2007 @ 13:50:
Even een lesje integer rekenen.

Laten we x = 1 / ( 2 * y + 1 ) eens uitsplitsen.

y is een integer.
Daarom is 2 * y een integer.
Daarom is 2 * y + 1 een integer.
1 is een integer.

Als je een integer deelt door een integer komt daaruit, verrassing, een integer! Namelijk de div (ofwel het wiskundige resultaat naar beneden afgerond). Als voorbeeld, 3 / 2 = 1.

Dat jij daarna deze integer aan een double assigned maakt niets uit, het is in principe nog steeds een geheel getal, alleen nu als double.


De oplossing hiervoor is simpel: zorg ervoor dat 1 van beide operands van je deling een double of float is. Dat kan door expliciet casten x = 1 / ( 2 * (double)y + 1 ), of als je met constanten werkt gewoon een .0 erbij zetten: x = 1.0 / ( 2 * y + 1 ).


Als samenvatting een stelregel:
Het type van het resultaat van een wiskundige operatie is:
- een double als minimaal 1 van de operands een double is
- anders een float als minimaal 1 van de operands een float is
- anders een long als minimaal 1 van de operands een long is
- anders een integer

Dus ook:

Java:

byte b1 = 0;
byte b2 = 1;
byte b3 = b1 + b2; // compile error: b1 + b2 levert een integer!

edit:
Wat hammerhead dus in een paar regels al zei...

Toch 1 toevoeging. en die mogen jullie opzoeken als je me niet gelooft.
Het resultaat is net iets anders als bovenstaande namelijk :
Het type van het resultaat van een wiskundige operatie is:
- een double als minimaal 1 van de operands een double is
- een double als minimaal 1 van de operands een float is
- een double als minimaal 1 van de operands een long is
- anders een integer

[Jaap-Jan]

Jochem Knoops schreef op woensdag 24 januari 2007 @ 15:00:
[...]

Toch 1 toevoeging. en die mogen jullie opzoeken als je me niet gelooft.
Het resultaat is net iets anders als bovenstaande namelijk :
Het type van het resultaat van een wiskundige operatie is:
- een double als minimaal 1 van de operands een double is
- een double als minimaal 1 van de operands een float is
- een double als minimaal 1 van de operands een long is
- anders een integer

Dat klopt zeker weten niet. Dit komt uit de Java Virtual Machine Specification:

quote: http://java.sun.com/docs/...l/Concepts.doc.html#16021

When an operator applies binary numeric promotion to a pair of numeric operands, the following rules apply, in order, using widening primitive conversion to convert operands as necessary:

• If either operand is of type double, the other is converted to double.

• Otherwise, if either operand is of type float, the other is converted to float.

• Otherwise, if either operand is of type long, the other is converted to long.

• Otherwise, both operands are converted to type int.

En hetzelfde geldt voor de taal Java zelf: http://java.sun.com/docs/...nversions.doc.html#170983

[ Voor 5% gewijzigd door Jaap-Jan op 24-01-2007 15:15 ]

[Verwijderd]

[ik moet leren lezen]

[ Voor 125% gewijzigd door Verwijderd op 24-01-2007 15:53 ]

[Robtimus]

Ik begon even aan mezelf te twijfelen na het lezen van de post van Jochem Knoops, maar dat SCJP certificaat hangt hier dus niet voor niks aan de muur