Fortolkning af rekursionskode (til lommeregner)

Smid den herind...

Der er i forvejen skrevet lidt kommentarer, men de er ikke uddybbende nok. De skal helst beskrives så et lille barn kan forstå koden ;) hvis det er muligt, vil jeg gerne anmode om et klassediagram også.. Den der vil hjælpe mig, skal være villig til at sende filer over mail.

Her er koden:
-----------------------------------------------------------------------------

public class Formelberegning
{
  /**
  * Finder første position af en operator, f.eks. +, -, * eller /.
  * Går uden om de operatorer, der er inde i en parentes.
  * Simpel løsning, der ikke tager højde for parenteser: udtryk.indexOf(tegn)
  */
  private static int findUdenforParenteser(char tegn, String udtryk)
  {
    int par = 0;
    for (int i = 0; i<udtryk.length(); i++)
    {
      char t = udtryk.charAt(i);
      if (t == tegn && par==0) return i; // tegn fundet udenfor parenteser!
      else if (t == '(') par++;          // vi går ind i en parentes
      else if (t == ')') par--;          // vi går ud af en parentes
    }
    return -1; // tegnet blev ikke fundet (i hvert fald ikke udenfor parenteser)
  }


  /**
  * Beregner værdien at et udtryk.
  * @param udtryk En streng med udtrykket, der skal beregnes.
  * @return værdien af udtrykket.
  * @throws NumberFormatException hvis udtrykket ikke er gyldigt
  */
  public static double beregn(String udtryk)
  {
    udtryk = udtryk.trim();                  // fjern overflødige blanktegn
    for (int opNr = 0; opNr < 4; opNr++)    // løb gennem de fire regnearter
    {
      char op = "+-*/".charAt(opNr);        // op er nu '+', '-', '*' eller '/'
      int pos = findUdenforParenteser(op,udtryk);
      if (pos > 0)                          // findes op i udtrykket?
      {
        String vs = udtryk.substring(0,pos); // ja, find venstresiden
        String hs = udtryk.substring(pos+1); // find højresiden

        // metoden kalder nu sig selv og analyserer hvert element i strengen
        double vsr = beregn(vs);            // beregn højresidens værdi
        System.out.println("beregn("+vs+") = "+vsr);
        double hsr = beregn(hs);            // beregn venstresidens værdi
        System.out.println("beregn("+hs+") = "+hsr);

        if (op == '+') return vsr + hsr;    // beregn resultat og returnér
        if (op == '-') return vsr - hsr;
        if (op == '*') return vsr * hsr;
        return vsr / hsr;
      }
    }
    // Hvis vi kommer herned kunne der ikke dele op i flere operatorer
    if (udtryk.startsWith("(") && udtryk.endsWith(")"))  // parenteser omkring?
    {
      udtryk = udtryk.substring(1,udtryk.length()-1);    // fjern dem
      return beregn(udtryk);                              // beregn indmad
    }
    if (udtryk.startsWith("sin(") && udtryk.endsWith(")"))// sinus-funktion
    {
      udtryk = udtryk.substring(4,udtryk.length()-1);    // fjern 'sin(' og )
      double resultat = beregn(udtryk);                  // beregn parameteren
      System.out.println("beregn("+udtryk+") = "+resultat);
      return Math.sin(resultat);
    }
    // intet andet fundet - så må det være et tal!
    // (ellers kastes NumberFormatException)
    return Double.parseDouble(udtryk);
  }

  public static void main(String[] arg)
  {
    String formel = "(1+2)*3 - sin(4/5*(6-7))";
    double værdi = beregn(formel);
    System.out.println("Formlen "+formel+" er beregnet til "+værdi);
  }
}

"Jeg skal udvikle en lommeregner. Idet jeg har fundet koden på nettet, er det ikke selve programmeringensdelen der er problemet."

Det er som man ser på det. Det er meget godt at læse andres kode og se eksempler, få hjælp osv. Men jeg går ud fra at projektet i java går ud på at lære at programmere selv, ikke at hente andres kode og få nogen til at forklare det. Programmeringsdelen er jo netop problemet hvis du ikke kan forstå det... og det lærer du kun ved selv at lave det.
Det er ikke dette der menes med at objektorienteret kode gør det nemmere at genbruge koden.

Lav hellere en lommeregner selv som du forstår.. det får du meget mere ud af.

Amen. Vil give dig ret i at en mindst lige så stor del af programmering, består i at kunne analysere og forstå koden. Men da jeg har en fastlagt deadline på dette projekt (meget snart), er jeg nødt til at bede om hjælp til beskrivelsen af koden..
Nogle der kan hjælpe mig??

Det er jo ekstremt fint dokumenteret.
Jeg kan ikke forstå du vil kommentere det yderligere. Desuden er koden jo ganske banal. Hvis du ikke forstår denne kode, og skal til en javaeksamen - så har du et problem.

Men det her er jo ikke nogen færdig lommeregner, og hvad skal du med et klassediagram når der kun er een klasse? Med kun to metoder...

Sæt dig ned og brug to timer på at læse koden grundigt igennem - så forstår du den garanteret også.

hehe, helt enig, men det er heller ikke tilfældet - er bare et projekt der skal skydes af. Er klar over det ikke direkte er en lommeregner, men mere en formelberegner.

Hvis du synes koden er så simpel, er du(cayman) måske den helt rigtige mand til opgaven - og 100 let tjente point..

Er ikke på point jagt - synes bare det er fedt at komme med faglige indspark, og håber at folk vil gøre det samme på mine spørgsmål.
Sidder til dagligt i stort J2EE projekt, og bruger rigeligt tid på at dokumentere min egen kode ;o)
Men held og lykke med projektet

Jeg vil klart fraråde at du bruger netop den kode som grundlag for din lommeregner. den er sølle. Og forresten ikke rekursiv som du siger.

Siden du har fået det projekt må en af nedenstående muligheder være korrekt:
a)  I har lært om syntaks og syntaktiske regler.
  Hvis det passer så lav lommeregneren så den implementerer og afspejler reglerne for en 'expression'.
b)  Du er overambitiøs og ønsker at imponere din hr lærer med paranteser ol. selvom ogaven ikke beder andet end en simpel 'gave for hurtigt svar' lommeregner med de fire regnearter ( +, -, *, / )

mvh JakobA

hmm.. beregn metoden kalder sig selv - er det ikke rekursivt ;o)

Men du har ret jakoba. Det er skod-kode hvis målet blot er at lave en lommeregner.
Jeg mener ikke der er grund til at bruge tung strenghåndtering i en lommeregner.  Det skal i givet fald kun være hvis man skal kune skrive expressions i den.
Der er bestemt ingen grund til heletiden at skulle konvertere strenge til double's. Spild af cpu..

God nat d'herrer

Du har ret, der er noget rekursion der. sorry.

en simper (ikke rekursiv) lommeregner:

variable:  reg1,  opr

a:  sæt opr til 'none', vis 0
b:  læs et tal            (hvis ikke et tal, så genstart fra b:)
  switch ( opr )
    'none':  flyt  tal til reg1
    'clear':  genstart fra a
    default:  beregn  reg1 opr tal => reg1
c:  vis reg1 
d:  læs en operator    (hvis ikke en operator, så genstart fra a:)
e:  flyt operator til opr
f:  fortsæt fra b

mvh JakobA