[java] moleculaire massa

[Verwijderd]

bestaat er ergens een classe die moleculaire massa van een molecule kan berekenen?

ik heb alle elementen in een HashSet gestoken (met hun atoommassa)
nu wil ik het gewicht van molecules berekenen

vb H2O = (2* atommassa van waterstof) + (1*atommassa van zuurstof)

of moet alles manueel worden ontleed en berekend?

[Cloud]

Verwijderd schreef op zondag 06 november 2005 @ 22:43:
bestaat er ergens een classe die moleculaire massa van een molecule kan berekenen?

ik heb alle elementen in een HashSet gestoken (met hun atoommassa)
nu wil ik het gewicht van molecules berekenen

vb H2O = (2* atommassa van waterstof) + (1*atommassa van zuurstof)

of moet alles manueel worden ontleed en berekend?

Nou een klasse weet ik niet, maar er zijn in ieder geval wel genoeg applets te vinden. En kijk! Daar staat zelfs al een linkje naar een site met dergelijke classes op! Heb je uberhaupt zelf wel gezocht?

edit:
Plus, nu je al zó ver bent, is het uitrekenen van die massa ook geen werk meer toch? Als je alle elementen en hun atoommassa's toch al in een Hash hebt zitten..

[ Voor 12% gewijzigd door Cloud op 06-11-2005 22:50 ]

[Verwijderd]

Is het moeilijk om zelf zo'n classe te schrijven dan ?

[Verwijderd]

ik zit een beetje gewrongen met de diverse elementen in een molecule
het ene element heeft één letter (O, H, C, ...), het andere heeft er twee(Fe, He, Na, ...)
komt er nog bij dat in een chemische formule de subscripletter aanheeft hoeveel maal
het element voorkomt (H2SO4= 2*H + 1*S + 4*O)

ik weet eigenlijk nog nie goed hoe ik eraan moet beginnen

[TweakBoy]

Verwijderd schreef op zondag 06 november 2005 @ 22:55:
ik weet eigenlijk nog nie goed hoe ik eraan moet beginnen

Begin je plan eerst in een schema of zo.. teken ene uml-case en analyseer van hoe het kan en op welk manier.. volgens mij heb je wel het vak Onderzoeksmethodiek gehad in de afgelopen periode op school...


het zelfde verhaal als dit:

[rml]-NMe- in "[ java] null pointer exeption"[/rml] ... lijkt er meer op dat je dat via je school moet vragen..

offtopic:
(naderhand bedacht: die opdrachten komen mij bekend voor )

[ Voor 51% gewijzigd door TweakBoy op 06-11-2005 23:03 ]

[Verwijderd]

wij kregen inderdaat diverse opdrachten
ik heb er ondertussen ( met jullie hulp) veel kunne oplossen
waarvoor bedankt

ondertussen worstel in verder met deze opdrachten
en probeer hulp te krijgen als ik ergens vast zit

dit is toch de bedoeling van dit forum? elkaar helpen?

erik

[Nitroglycerine]

Het forum is om elkaar te helpen, maar niet om je huiswerk te maken.


Ik ben niet thuis in Java, maar heb ooit chemie gestudeerd voordat ik de ICT inrolde. Als ik het in bash zou moeten doen, dan zou ik de opgegeven formule ontleden. Er zijn iets van 109 elementen, met unieke aanduidingen. In de chemie volgt op het element de hoeveelheid.
Dus bijvoorbeeld
C6H12O6
karakter voor karakter doorlopen. C -> match koolstof, massa 12. Volgende karakter: 6, dus 6*C enzovoorts.

Je zult behoorlijk wat af moeten checken, bijvoorbeeld Cu CUr (niet dat zo'n verbinding mogelijk is, maar het gaat om het idee).

[Verwijderd]

dat weet ik
(je formule gaf trouwens alcohol aan, juist?)
ik ben enkel aan het uitzoeken hoe je de formule moet ontleden

je helpen mij, dat geef ik graag toe
maar de huistaken zijn veel meer omvattend dat wat ik op het forum vraag

toch bedankt

[Verwijderd]

sorry, suiker

[Verwijderd]

Verwijderd schreef op zondag 06 november 2005 @ 23:13:
dat weet ik
(je formule gaf trouwens alcohol aan, juist?)
ik ben enkel aan het uitzoeken hoe je de formule moet ontleden

je helpen mij, dat geef ik graag toe
maar de huistaken zijn veel meer omvattend dat wat ik op het forum vraag

toch bedankt

Volgens mij is het glucose Maar wat betreft je probleem, het keyword parsen omschrijft het ontleden van de input in de juiste tokens. Als ik jou was zou ik me eerst wat verdiepen in welke mogelijkheden Java biedt om de input te parsen naar de juiste tokens. Als je die tokens eenmaal hebt kan je makkelijk objecten maken die een atoom representeren, en dus makkelijk de moleculaire massa uitrekenen.

[Verwijderd]

ok,
zal eens kijken

bedankt

[Bluestorm]

Het beste werkt als je eerst eens voor jezelf precies bedenkt hoe je zelf eigenlijk die string leest en omzet in een massa als je het handmatig doet. Je pakt gewoon een aantal voorbeelden en kijkt wat de mogelijkheden zijn, hoe je de verschillende gevallen kunt onderscheiden en wat je er vervolgens mee zou moeten doen.

Voor het eerste teken van je string bijvoorbeeld, dat kan alleen maar de eerste letter zijn die een element beschrijft. Weet je dan al genoeg om te bepalen wat er mee moet? En als je meer tekens moet lezen, wat kan er dan daarna komen, etc.

[Bergie]

De manier die C3H5N3O9 ( ) geeft lijkt mij de meest makkelijke. Ontleed het molecuul naar alle afzonderlijke elementen en hoe vaak ze voorkomen in het molecuul.

Het probleem van C en bijvoorbeeld Cu zou je op kunnen lossen door met case sensitivity te werken. Als je er van uit gaat (eist) van je input dat die case sensitive is (dus Cu en geen CU als input gebruiken) moet dit geen probleem zijn.

[Verwijderd]

ok,
zal het proberen

[Daos]

Verwijderd schreef op zondag 06 november 2005 @ 23:16:
[...]


Volgens mij is het glucose Maar wat betreft je probleem, het keyword parsen omschrijft het ontleden van de input in de juiste tokens. Als ik jou was zou ik me eerst wat verdiepen in welke mogelijkheden Java biedt om de input te parsen naar de juiste tokens. Als je die tokens eenmaal hebt kan je makkelijk objecten maken die een atoom representeren, en dus makkelijk de moleculaire massa uitrekenen.

Parsen is al een stap verder (is voor herkennen van syntax). Van input naar tokens wordt gedaan door een Lexical Analyser ookwel Lexer. Soms wordt het ook tokenizer genoemd.

offtopic:
Het wordt veel fout gedaan. Andersom ook. Een syntaxhighlighter heeft bijvoorbeeld niets met de syntax te maken.

TweakBoy schreef op zondag 06 november 2005 @ 23:01:
Begin je plan eerst in een schema of zo.. teken ene uml-case en analyseer van hoe het kan en op welk manier.. volgens mij heb je wel het vak Onderzoeksmethodiek gehad in de afgelopen periode op school...

Aan UML heb je (in dit geval) niet zoveel. Gewoon met blokjes een schema maken op papier en je bent zo goed als klaar. Bijvoorbeeld

code:

[start]
    |<------------------------*
   \ /          N             |
<is er nog iets?>--> [stop]   |
    | J                       |
    |                         |
   \ /                        |
[lees letter]<-----------*    |
    |                    |    |
   \ /                 J |    |
<is er nog een letter?>--*    |
    | N                       |
    |<------------------*     |
   \ /                  |     |
<is er nog een cijfer?>-|-----* 
    | J               N |
   \ /                  |
[lees cijfer]           |
    |                   |
    *-------------------*

Bergie schreef op zondag 06 november 2005 @ 23:19:
De manier die C3H5N3O9 ( ) geeft lijkt mij de meest makkelijke. Ontleed het molecuul naar alle afzonderlijke elementen en hoe vaak ze voorkomen in het molecuul.

Het probleem van C en bijvoorbeeld Cu zou je op kunnen lossen door met case sensitivity te werken. Als je er van uit gaat (eist) van je input dat die case sensitive is (dus Cu en geen CU als input gebruiken) moet dit geen probleem zijn.

Elementen zijn case sensitive. CU is Koolstof met Uraan.

Er zijn ook nog haakjes mogelijk in formules.
Neem bijvoorbeeld ijzer(III)hydroxide: Fe(OH)3 = 1 * Fe + 3 * O + 3 * H

[Reptile209]

Daos schreef op zondag 06 november 2005 @ 23:53:
[...]

Elementen zijn case sensitive. CU is Koolstof met Uraan.

Er zijn ook nog haakjes mogelijk in formules.
Neem bijvoorbeeld ijzer(III)hydroxide: Fe(OH)3 = 1 * Fe + 3 * O + 3 * H

En nog lastiger: met liganden... [Ni(CN)4]^2-, of dingen als Cu(III). Dus bedenk eerst goed wat je wel en niet wilt kunnen parsen, en wat je parser moet doen als hij het niet meer weet.

[Confusion]

Die laatste soorten maken voor de massa niets uit (die paar electronen kan je verwaarlozen) en daar hoef je dus niet mee om te kunnen gaan. Wel in de doc vermelden dat alles anders dan letters, cijfers en parenthesis een IllegalArgumentException zal produceren (en III is geen element ).

[ Voor 6% gewijzigd door Confusion op 07-11-2005 10:50 ]

[Daos]

Je kan gewoon zoiets doen:

Java:

  public static int berekenMassa(String formule) {
    return berekenMassa(formule, new Int());
  }

  private static int berekenMassa(String formule, Int positie) {
    int massa = 0;
    String element;
    int deelMassa = 0;
    int aantal;

    while (positie.value < formule.length()) {
      // haakjes
      if (formule.charAt(positie.value) == '(') {
        positie.value ++;
        deelMassa = berekenMassa(formule, positie);
      }
      else if (formule.charAt(positie.value) == ')') {
        positie.value ++;
        return massa;
      }
      // of element
      else if (Character.isUpperCase(formule.charAt(positie.value))) {
        element = leesElement(formule, positie);
        deelMassa = zoekMassa(element);
      }

      // en daarna optioneel aantal
      if (positie.value < formule.length() &&
             Character.isDigit(formule.charAt(positie.value)))
        aantal = leesAantal(formule, positie);
      else
        aantal = 1;

      massa += deelMassa * aantal;
    }

    return massa;
  }

De positie wordt in een object van de volgende klasse opgeslagen omdat de positie verandert bij de lees-methoden en de recursieve aanroep bij het haakje.

Java:

public class Int {
  public int value = 0;
}

De methoden leesElement(..), zoekMassa(..) en leesAantal(..) zijn niet zo moeilijk te maken. Het bovenstaande algoritme houdt geen rekening met foute invoer.

De recursie met de haakje kan je ook anders doen: Je kan het stukje tussen de haakjes opzoeken en meegeven aan "public static int berekenMassa(String formule)". Het probleem hiermee is dat je haakjes moet gaan tellen om te kijken welke ')' bij je '(' hoort.

[Hydra]

TweakBoy schreef op zondag 06 november 2005 @ 23:01:
Begin je plan eerst in een schema of zo.. teken ene uml-case en analyseer van hoe het kan en op welk manier..

Hoezo overengineering

Maak een readertje die molecuulstrings kan lezen. Leuke vingeroefenings voor een statemachine die je even op een kladblok uit kan tekenen. Aan de ene kant gaat de string d'r in, aan de andere kant spuug je combinaties van atoomnamen en aantallen uit. Getal staat altijd voor de atoomnaam. Staat er geen getal dan is het er 1. Kom je na een hoofdletter weer een hoofdletter tegen dan heb je weer een volgende atoom te pakken.

Edit: *kuch* eerst letter, dan cijfer, al weer te lang geleden

Daos schreef op maandag 07 november 2005 @ 13:58:
Je kan gewoon zoiets doen:

Beetje lelijk. Het is IMHO netter het splitsen van de string niet in dezelfde methode te doen als de berekening.

[ Voor 20% gewijzigd door Hydra op 07-11-2005 18:07 ]

[Paul]

Daos schreef op maandag 07 november 2005 @ 13:58:
Het probleem hiermee is dat je haakjes moet gaan tellen om te kijken welke ')' bij je '(' hoort.

Neem dan gewoon de eerste ) en zoek in het stuk ervoor naar de laatste (

[Daos]

Paul Nieuwkamp schreef op maandag 07 november 2005 @ 18:57:
[...]
Neem dan gewoon de eerste ) en zoek in het stuk ervoor naar de laatste (

Dat maakt niets uit. Het ging mij om geneste haakjes. Neem bijvoorbeeld:

code:

A(B(C(D)E(F)G)H(I)J)K(L)M

Hoe kan je nu makkelijk zien dat '(' tussen A en B wordt afgesloten met ')' tussen J en K?
Dat kan je volgens mij alleen zien door de haakjes er tussen te bekijken.

[edit]
Jouw methode pakt eerst D, dan F, F)G, I, I)J en vervolgens L. Ik zie niet zo snel wat je daar aan hebt.

De bedoeling van recursie is dat je het probleem steeds kleiner maakt. Je begint met A(B(C(D)E(F)G)H(I)J)K(L)M en je roept vervolgens dezelfde methode aan met B(C(D)E(F)G)H(I)J en L.
In de functieaanroep met B(C(D)E(F)G)H(I)J als argument wordt dezelfde methode aangeroepen met C(D)E(F)G en I. In de functieaanroep met C(D)E(F)G als argument wordt dezelfde methode aangeroepen met D en F.

[ Voor 40% gewijzigd door Daos op 07-11-2005 19:39 ]

[Paul]

recursief moet je inderdaad haakjes gaan tellen.

Als je iteratief alle haakjes wegwerkt door met de eerste ) te beginnen werk je ook je haakjes weg en hoef je niet allemaal countertjes bij te gaan houden waar welk haakje bij hoort.
Ipv per char te kijken of je een ( tegenkomt en dan net zolang ( en ) tellen tot je evenveel ( als ) hebt kun je met Pos(")") en LastPos("(") je haakjes bij elkaar zoeken en oplossen.

Veel kans gaat Pos en LastPos intern ook per char de string af, dus of het voor de performance beter is zou ik niet weten, maar (behalve dat een iteratief iets sneller gesnapt wordt door de meesten dan eenr ecursief iets) je procedure wordt er ook simpeler/korter van, wat de leesbaarheid en dus het onderhoud / bughunten ten goede komt.