[JAVA] rekenen met letters

[Zynth]

Is er een manier in java om te rekenen met letters?
voorbeeld:
2a / 2 = a
a + a = 2a

Of weet iemand misschien een logaritme?

thnx!

[mbravenboer]

Zynth: Is er een manier in java om te rekenen met letters?

Je bedoelt waarschijnlijk dat je wilt rekenen met vergelijkingen die variabelen kunnen bevatten (geen variabelen in Java dus). Hier zijn dus geen standaardvoorzieningen voor. Je kan wel vrij eenvoudig zelf iets schrijven om met vergelijkingen te werken.

Als je iets meer vertelt over je probleem, kan het echt vast beter worden opgelost .

Of weet iemand misschien een logaritme?

algoritme?

[Janoz]

Op dinsdag 06 november 2001 12:33 schreef Zynth het volgende:

Of weet iemand misschien een logaritme?

thnx!

* Janoz en Tsjipmanz weten wel een logaritme!

code:

Math.log(double a);

Nee ff serieus, je kan het beste een expressieboom hiervoor gebruiken en hier de expressies in "ophangen".

[Scorpion]

dus niet:

code:

int a = 1;
int b = 2 * a;

of wel?

[Tsjipmanz]

Op dinsdag 06 november 2001 13:11 schreef Scorpion het volgende:
dus niet:

code:

int a = 1;
int b = 2 * a;

of wel?

Laat dat maar niet aan de datacase-teamleider zien.
Wat de topicstarter bedoelt is in feite het gebruik van variabelen zonder hier een concrete waarde voor in te vullen, zoals een functievoorschrift in feite ook is.

De vergelijking voor een parabool is bv

code:

Y = 2*X^2 + 4 X - 18

Dat soort dingen zijn soms te herschrijven in termen van X. Als je dus zoals jij doet waarden gaat toekennen aan die variabelen wordt dat al een stuk moeilijker, zo niet onmogelijk.

[tomato]

Hier hebben we oa Mathematica, Maple en Matlab voor. Wil je ingewikkeld, dan maak je dit niet zomaar.

[roelio]

op zich is het best te doen, met een boom inderdaad. En dan ff er vanuitgaand dat je alleen + - * / en mogelijk haakjes wilt gebruiken ... maar ik zou eens op het web gaan neuzen want ik geef je een redelijke kans dat er zo'n algoritme rondzwerft (en misschien zelfs voor Java) ...

[Janoz]

Op dinsdag 06 november 2001 13:42 schreef limoentje het volgende:
op zich is het best te doen, met een boom inderdaad. En dan ff er vanuitgaand dat je alleen + - * / en mogelijk haakjes wilt gebruiken ... maar ik zou eens op het web gaan neuzen want ik geef je een redelijke kans dat er zo'n algoritme rondzwerft (en misschien zelfs voor Java) ...

Met een boom is veel meer mogelijk hoor .. Heb een tijdje terug hetzelfde gedaan, daarbij zat ook de ^ operator (dus ook wortel, want dat is gewoon tot de macht <1) nadat je die boom hebt is het ook niet zo heel moeilijk meer om de boel te differentieren (Integreren is al wat lastiger)

[Nappa]

Op dinsdag 06 november 2001 13:49 schreef Janoz het volgende:

[..]

Met een boom is veel meer mogelijk hoor .. Heb een tijdje terug hetzelfde gedaan, daarbij zat ook de ^ operator (dus ook wortel, want dat is gewoon tot de macht <1) nadat je die boom hebt is het ook niet zo heel moeilijk meer om de boel te differentieren (Integreren is al wat lastiger)

Mwoahh, wel een beetje vies he! Het is nog altijd tot de macht 0 < n < 1

Is trouwens volgens mij moeilijker dan het lijkt. Hee Janoz hebben we dat in het eerste jaar niet moeten doen?? In pascal volgens mij, misschien heb ik nog wel wat code liggen.

[edit]
Oh nee, niet meer na mijn kleine 'rm -rf'-accidentje... Sorry!

[roelio]

Op dinsdag 06 november 2001 13:49 schreef Janoz het volgende:

[..]

Met een boom is veel meer mogelijk hoor .. Heb een tijdje terug hetzelfde gedaan, daarbij zat ook de ^ operator (dus ook wortel, want dat is gewoon tot de macht <1) nadat je die boom hebt is het ook niet zo heel moeilijk meer om de boel te differentieren (Integreren is al wat lastiger)

janoz, beste maat van tsjipmanz, natuurlijk weet ik ook wel dat er veel meer mogelijk is met een boom, maar het kan relatief lang duren om ingewikkelder zaken dan ()+/-* te maken ... vandaar dat je je als newB beter eerst kunt concentreren op deze relatief eenvoudige bewerkingen en niet meteen proberen allerlei ingewikkelder expressies toe te voegen. Maar goed, dat geldt voor een heleboel programmeerklussen
Anywayz om een lang verhaal kort te maken: ik bedoel dat het een goed plan is om eerst alleen de vier simpele operatoren te implementeren *+/-

[Tsjipmanz]

Op dinsdag 06 november 2001 13:59 schreef limoentje het volgende:

[..]
Anywayz om een lang verhaal kort te maken: ik bedoel dat het een goed plan is om eerst alleen de vier simpele operatoren te implementeren *+/-

EN haakjes ()
Die expressies moeten dan weer eerst geevalueerd worden en kunnen in hun geheel in een sub-boom worden gezet.

[roelio]

Op dinsdag 06 november 2001 14:05 schreef Tsjipmanz het volgende:

[..]

EN haakjes ()
Die expressies moeten dan weer eerst geevalueerd worden en kunnen in hun geheel in een sub-boom worden gezet.

okayy tsjippp foaruut mar wer

[Zynth]

Omdat er nogal wat onduidelijkheid heerst, zal ik het nog even uitleggen.

Ik wil rekenen met "letters".
Op die letters wil ik elementaire operatoren (*, /, -, +)
kunnen toepassen,
zodat: a+a= 2a, en bijvoorbeeld: ab/a=b
het is dus zeg maar 2e klas rekenwerk :-)
Ik hoef geen vergelijkingen te kunnen oplossen.
De code moet alleen maar in staat zijn om operatoren toe te passen op letters.
nog een paar voorbeelden voor de duidelijkheid:
als ik invoer in java: (2*a*b)/b, dan moet java als output geven: 2a

Is dit een beetje te doen?
Met een ALgoritmetje [thnx mbravenboer ;)]

---------------
Voor de wiskunde freakz
onze programmeerleraar heeft ons beloofd dat wij een voldoende zouden krijgen op wiskunde, als wij een java-programma zouden maken die matrices (evt. ook met letters) op canonieke standaard rijvorm brengt, (Gauss-Jordan principe), vandaar

[mbravenboer]

Je wilt dus gewoon expressies evalueren....

Dat kan je op heel veel verschillende manieren doen:

1. Beetje aan rommelen

2. Grammatica maken voor je expressies, parser genereren en de resulterende boom evalueren. Klinkt moeilijk, maar het is de netste oplossing en de oplossing met de laagste lokale complexiteit.

3. Gebruik een scripting-omgeving vanuit Java. Dit is veruit de makkelijkste manier voor dit eenvoudige probleem. Er was hier pas een topic over. Ik zal even zoeken .

[mbravenboer]

Hier gaat het over precies hetzelfde probleem. Hier is uiteindelijk de oplossing van scripting gekozen met Beanshell. Dit is een hele populaire scripting engine voor Java. Er staat zelfs een stukje voorbeeld code bij .

[topic=288179/1/25]

Edit: er staan eerst veel andere oplossingen, daar moet je maar ff overheen lezen (of niet ).

[mbravenboer]

Hum nu ik er nog even over nadenk.... Dit was niet echt van toepassing omdat de variabelen nog geen waarde hebben ...

Als je onder Unix/Linux werkt is Stratego een hele mooie oplossing, maar dat zal wel weer wat ver gaan.

Je kunt het beste maar even naar een lib zoeken die dit biedt, want het zal niet triviaal worden om dit te implementeren. Ik zal even rondkijken of ik iets kan vinden.

[mbravenboer]

Hum hier is een lange lijst van wiskundige java libs, wellicht dat er iets tussen zit.

www.jars.com science math

Misschien dat JEP dit aan kan, maar ik denk het eerlijk gezegd niet als ik de omschrijving zo lees:

http://jep.sourceforge.net

edit: hum, ik post teveel .

[tomato]

Op dinsdag 06 november 2001 23:12 schreef Zynth het volgende:
Voor de wiskunde freakz
onze programmeerleraar heeft ons beloofd dat wij een voldoende zoden krijgen op wiskunde, als wij een java-programma zouden maken die matrices (evt. ook met letters) op canonieke rijvorm brengt, met het Gauss-Joradn principe;
vandaar

Je wilt dus eigenlijk gewoon matrices tot gereduceerde echelonvorm transformeren. Eerst naar echelonvorm van boven naar beneden (Gauss) en dan tot gereduceerde echelonvorm op de terugweg (Gauss-Jordan).
In principe hoef je dus alleen uitdrukkingen te vermenigvuldigen met een scalar en uitdrukkingen van elkaar af te trekken en hoef je geen echt ingewikkelde dingen te doen.

Als we even wachten op mbravenboer heeft ie vast nog wat nuttigs voor je

[Verwijderd]

JavaCC schijnt de/een java tegen hanger te zijn van lexx en yacc, wellicht een leuk begin?

[mbravenboer]

Yarvieh: JavaCC schijnt de/een java tegen hanger te zijn van lexx en yacc, wellicht een leuk begin?

JavaCC is inderdaad wel goed (oorspronkelijk ontwikkeld bij Sun, nu al een paar keer van eigenaar veranderd). JLex en CUP zijn echter de 'echte' tegenhangers van lexx en yacc denk ik.

Maar dat is slechts de stap van het parsen van een expressie. Dat is nog niet het grootste probleem. Daarna komt het meeste werk: herschrijven van de expressies en het toepassen van operaties. Helaas is Java (en geen enkele OO taal) echt geschikt om dergelijke zaken mooi te implementeren.

[roelio]

Op dinsdag 06 november 2001 23:39 schreef mbravenboer het volgende:
...
Helaas is Java (en geen enkele OO taal) echt geschikt om dergelijke zaken mooi te implementeren.

ik hoop niet dat je hiermee bedoelt dat procedurele talen hier wel geschikt voor zijn (dan kan het met OO net zo goed), we doelen hier meer op FP ofzo, right??

[tomato]

Misschien kun je hier iets mee?

[mbravenboer]

limoentje: ik hoop niet dat je hiermee bedoelt dat procedurele talen hier wel geschikt voor zijn (dan kan het met OO net zo goed)

Nee hoor, wees niet bang . In OO kan het dan naar mijn mening nog fraaier met wat abstract-syntax-trees en visitors implementeren.

we doelen hier meer op FP ofzo, right??

FP kan inderdaad ja. Er zijn echter ook speciale talen voor programma transformaties. Op het moment ben ik een liefde aan het ontwikkelen van Stratego. In deze taal kan je met behulp van een verzameling van eenvoudige term-herschrijf regels allerlei transformaties uitvoeren (en dus ook evalueren). Je kunt hier echt enorm makkelijk behoorlijk ingewikkelde dingen mee doen.

De eerste uitleg van Stratego gaat bijvoorbeeld over het parsen van logische formules en het transformeren naar disjunctieve of conjunctieve normaal vorm. Zelfs het interpreteren van een programmeertaal is geen enkel probleem. Er is ook een voorbeeld implementatie van de interpretatie van Tiger (de taal gebruikt in het boek van Andrew w. Appel: Modern Compiler Implementation in Java/C/ML). Voor het vak wat ik nu volg (High-Peformance compilers) moeten we een volledige compiler voor Tiger naar native code schrijven met later nog wat optimalisaties.

Krachtig taaltje dus . Dit probleem zou daar zeer fraai in op te lossen zijn... Helaas is de leer-curve waarschijnlijk iets te ongunstig om dat ook zomaar even te gaan doen.

[roelio]

Op dinsdag 06 november 2001 23:45 schreef tomato het volgende:
Misschien kun je hier iets mee?

deze tool evalueert (herschrijft) de formule niet, het geeft alleen maar een grafische weergave van een formule die jij opgeeft...