[HaBo]

public class UPNModul {

	// Der Zahlen-Stack
	private static Stack digits = new Stack();

	//Die Methode löst die eigebene Gleichung und gibt das Ergebnis als String zurück
	public static String solve(String line) throws RuntimeException {

		String number = ""; //Zwischenspeicher, um eine komplette Zahl zusammenzusetzn
		boolean floatFound = false; //Prüft, ob die Zahl schon einen Punkt hat
		while(!digits.isEmpty())
			digits.pop();
		
		for(int i=0; i<line.length(); i++) {
			
			char c = line.charAt(i); //Das aktuelle Zeichen
			
			//Ziffern oder der erste Punkt (Alle weiteren Punkte gehören nicht zur Zahl)
			if(Character.isDigit(c) || (c == '.' && !floatFound)) {
				number+=c; //Aktuelle Ziffer zum Zwischenspeicher hinzufügen
				if(c=='.') floatFound = true;
			}
			//Operatoren oder Leerzeichen
			else if(c == ' ' || c == '+' || c == '-' || c=='*' || c=='/') {
				//Die Zahl im Zwischenspeicher auf den Stack legen (wenn im Zwischenspeicher etwas steht)
				if(!number.equals("")) {
					numberInStack(number, floatFound);
					floatFound = false;
					number = "";
				}
				if(c == ' ') continue; //Wenn Leerzeichen: Prüfe das nächste Zeichen

				//Die 2 Zahlen aus dem Stack
				float digit1;
				float digit2;
				try {
					digit2 = (Float) digits.pop();
					digit1 = (Float) digits.pop();
				} catch (RuntimeException e) {
					//Wenn keine 2 Zahlen im Stack liegen (RuntimeException vom Stack) ist die Gleichung fehlerhaft
					throw new RuntimeException("Die Gleichung entspricht nicht der Postfixnotation");
				}
						
				//Je nach Operator wird das Ergebnis berechnet und wieder auf den Stack gelegt
				switch(c) {
				case '+': 
					digits.push(digit1 + digit2);
					break;
				case '-':
					digits.push(digit1 - digit2);
					break;
				case '*':
					digits.push(digit1 * digit2);
					break;
				case '/':
					digits.push(digit1 / digit2);
					break;
				}
			// Wenn es keine Ziffer, kein Leerzeichen und kein Operator war: Fehler
			} else {
				throw new RuntimeException("Falsche Eingabe: "+c);
			}
		}
		//Das Endergebnis aus dem Stack holen und als String zurück geben
		String result = ""+digits.pop();
		if(!digits.isEmpty() || !number.equals(""))
			throw new RuntimeException("Die Gleichung entspricht nicht der Postfixnotation");
		if(result.endsWith(".0"))
			result = result.substring(0,result.length()-2);
		return result;
	} //solve
	
	//Schreibt eine Zahl als Float oder Integer in den Stack
	private static void numberInStack(String number, boolean floatFound) {
		//Wenn die Zahl nur aus einem Punkt besteht wird dieser ignoriert
		if(number.startsWith(".") && number.length()==1) {
			number = "";
			return;
		}
		//Wenn die Zahl mit einem Punkt aufhört wird der Punkt abgeschnitten
		if(number.endsWith(".")) {
			number = number.substring(0,number.length()-1);
			floatFound = false;
		}
		digits.push(Float.parseFloat(number));
	} //numberInStack
}

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

public class UPNFrame extends JFrame implements ActionListener{

	private static final long serialVersionUID = -7501896257995843922L;
	
	private JPanel inputPanel, outputPanel;
	private JTextField input, output;
	private JLabel inputLabel, outputLabel;
	private JButton ok;
	
	public UPNFrame() {
		super("UPN-Rechner");
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		input = new JTextField(20);
		output = new JTextField(10);
		inputLabel = new JLabel("Eingabe: ");
		outputLabel = new JLabel("Ergebnis: ");
		ok = new JButton("Enter");
		
		inputPanel = new JPanel(new FlowLayout(FlowLayout.LEFT,10,5));
		inputPanel.add(inputLabel);
		inputPanel.add(input);
		inputPanel.add(ok);
		
		outputPanel = new JPanel(new FlowLayout(FlowLayout.LEFT,10,5));
		outputPanel.add(outputLabel,BorderLayout.NORTH);
		outputPanel.add(output,BorderLayout.SOUTH);
		
		ok.addActionListener(this);
		input.addActionListener(this);
		
		this.setLayout(new BorderLayout());
		this.add(inputPanel,BorderLayout.NORTH);
		this.add(outputPanel, BorderLayout.SOUTH);
		
		this.pack();
		this.setLocationRelativeTo(null);
		this.setVisible(true);
	} //ExtractFrame
	
	public void actionPerformed(ActionEvent e) {
		if(!input.getText().equals("")) {
			try {
				String result = UPNModul.solve(input.getText());
				output.setText(result);
			} catch(RuntimeException exc) {
				JOptionPane.showMessageDialog(this, exc.getMessage(), "Fehler", JOptionPane.ERROR_MESSAGE);
			}
			
		}	
	} //actionPerformed
	
	public static void main(String[] args) {
		new UPNFrame();
	} //main
}

#!/usr/bin/env perl
use warnings;
use strict;
use Getopt::Std;

# A little script for parsing mathematical expressions.

my $Operator = qr{[-+/%*x]};
my $Number = qr{[-+]?(:?(:?[1-9][0-9]*)?\.)?[1-9][0-9]*};
my $Bracket = qr{[)(]};


sub calcPostfix {
    my @numStack;
    foreach my $atom (@_) {
        if ($atom =~ m{^$Number$}) {push(@numStack, $atom)}
        elsif ($atom =~ m{^$Operator$}) {
            my ($b, $a) = (pop(@numStack), pop(@numStack));
            unless ($a) {$a = 0}
            unless ($b) {$b = 0}
            my $result;
            if    ($atom eq '*' or $atom eq 'x'){$result = $a * $b}
            elsif ($atom eq '/' or $atom eq '%'){$result = $a / $b}
            elsif ($atom eq '+')                {$result = $a + $b}
            elsif ($atom eq '-')                {$result = $a - $b}
            push(@numStack, $result)
        }
    }
    return pop(@numStack)
}

sub infix2postfix {
    my (@postfixTerm, @opStack);
    # A precendence-hash mapping operators to integers representing their precendence.
    my %precHash = ('*'   =>   2,
                    'x'   =>   2,
                    '%'   =>   2,
                    '/'   =>   2,
                    '+'   =>   1,
                    '-'   =>   1,
                    ')'   =>   0,
                    '('   =>   0,
                    'EOT' =>   0);

    push(@opStack, "EOT");
    PARSE: foreach my $atom (@_, "EOT") {       # EOT == "End of term" mark
        if    ($atom =~ m{^$Number$}) {push(@postfixTerm, $atom)}
        elsif ($atom =~ m{^$Operator$}) {
            if ($precHash{$atom} > $precHash{$opStack[$#opStack]}) {push(@opStack, $atom)}
            else {
                push(@postfixTerm, pop(@opStack));
                redo PARSE
            }
        }
        elsif ($atom =~ m{^$Bracket$}) {
            if ($atom eq '(') {push(@opStack, $atom)}
            else {
                while($opStack[$#opStack] ne '(') {push(@postfixTerm, pop(@opStack))}
                pop(@opStack)
            }
        }
        elsif ($atom eq "EOT") {
            push(@postfixTerm, pop(@opStack)) until ($opStack[$#opStack] eq "EOT")
        }
    }
    return @postfixTerm
}

sub Help {
    print "Usage: $0 [switch] [argument]\n\n";
    print "Available switches:\n";
    print "-h\t\tDisplay this help text and exit.\n";
    print "-i\t\tThis switch takes a term in infix notation as an argument.\n";
    print "-p\t\tThis switch takes a term in postfix notation as an argument.\n\n";
    print "Note: The postfix-notation has to be seperated by whitespaces.\n";
    print "This here for example:           $0 -p \'1 2 + 3 *\'\n";
    print "will work, while this here:      $0 -p \'1 2+ 3*\'\n";
    print "won\'t. Same goes for the infix notation, though the braces may\n";
    print "\"touch\" the digits like this:  $0 -i \'(1 + 2) * 3\'\n";
    exit(0)
}


unless (@ARGV) {Help()}

my %opts;
getopts('hi:p:', \%opts);

if (exists($opts{'h'})) {Help()}
print "<--Postfix Calculator---|\n";
print "                 \t|---------------------------------------------------------->\n";
if (exists($opts{'p'})) {
    print "Postfix notation:\t|\t$opts{'p'}\n";
    print "Result:          \t|\t".calcPostfix(split(/\s+/, $opts{'p'}))."\n";
    print "                 \t|---------------------------------------------------------->\n"
}
if (exists($opts{'i'})) {
    my @ifNotation = grep(/[^\s]+/, split(m{\s+|(?<=[\)-+/%*x0-9])(?=[)(])|(?<=[)(])(?=[\(-+/%*x1-9])}, $opts{'i'}));
    my @pfNotation = infix2postfix(@ifNotation);
    print "Infix notation:  \t|\t@ifNotation\n";
    print "Postfix notation:\t|\t@pfNotation\n";
    print "Result:          \t|\t".calcPostfix(@pfNotation)."\n";
    print "                 \t|---------------------------------------------------------->\n"
}