✔ Definition/Darstellung von Mathematischen Funktionen

F

flashray

Erfahrenes Mitglied
Hallo Freunde,

gibt es in java eine einfache Möglichkeit mathematische Funktionen zu definieren? Möchte nicht parsen, auch keine externe Bibliothek benutzen. Hier das Beispiel funktioniert leider nicht. Da x automatisch den Wert 0 zugewiesen bekommt, sind somit function1 und function2 beide gleich 0.

Code: 
public class Test {
	
	static double x;
	
	static double function1 = x * x;
	
	static double function2 = 2 * x;
	
	public static void solve(double[] numbers, double function) {
		for (int i = 0; i < numbers.length; i++) {
			x = numbers[i];
			System.out.println("result :" + function);
		}
	}

	public static void main(String[] args) {
		solve(new double[] {1,2,3},function1);
	}
}

Vg Erdal
 
Du könntest Dir ein "Wrapper-Interface" oder eine abstrakte Klasse, von der konkrete Klassen mit der jeweiligen Funktion erben, dafür schreiben, wie zum Beispiel das Interface Comparator für Vergleichsfunktionen aus der API.

Gruß hpvw
 
Hallo Jörg,

kannst du mir vielleicht sagen wo ich das nachlesen oder mir ein Beispiel ansehen kann. Hab nicht so richtig verstanden, wie du es meinst.

Vg Erdal
 
Ich habe mal ein schnelles Beispiel gemacht:

Zunächst das Interface CalcStrategy:
Code: 
package calcStrategy;

/**
 * 
 * @author hpvw
 */
public interface CalcStrategy {
    public double calc(double d);
}
Es wird für alle Klassen, die dieses Interface implementieren, vorgeschrieben, dass sie die Methode calc implementieren, welche ein double entgegennimmt und ein double zurückgibt.

Dann folgen die beiden konkreten Klassen zur Berechnung:

CalcPower
Code: 
package calcStrategy;

/**
 * 
 * @author hpvw
 */
public class CalcPower implements CalcStrategy {

    public double calc(double d) {
        return d*d;
    }

}

CalcDouble
Code: 
package calcStrategy;

/**
 * 
 * @author hpvw
 */
public class CalcDouble implements CalcStrategy {

    public double calc(double d) {
        return 2 * d;
    }

}

Und zu guter letzt die Testklasse Test:
Code: 
package calcStrategy;

/**
 * 
 * @author hpvw
 */
public class Test {

    public static void solve(double[] numbers, CalcStrategy cS) {
        for (int i = 0; i < numbers.length; i++) {
	    double x = numbers[i];
            System.out.println("result :" + cS.calc(x));
        }
    }

    public static void main(String[] args) {
        CalcStrategy cDouble = new CalcDouble();
        CalcStrategy cPower = new CalcPower();
        solve(new double[] {1,2,3},cPower);        
        solve(new double[] {1,2,3},cDouble);        
    }
}

Die Ausgabe:
Code: 
result :1.0
result :4.0
result :9.0
result :2.0
result :4.0
result :6.0

Gruß hpvw
 
Wenn du nen Funktionsparser für alle Mathematichen Funktionen benötigst, kannst du ne pn an mich senden, hab sowas da (selbst programmiert), will den nur noch nicht veröffentlichen da ich ihn noch für einen Wettbewerb brauche und sicher gestellt werden muss, das der Quelltext von mir stammt, was bei vervielfältigung im Inet schwierig ist. Der Parser kann + - * / sin cos tan pi e pow und sqrt von geklammerten Ausdrücken (als String vorliegend) auswerten und ist sehr leicht zu erweitern.

Greetz
 
Hallo MasterHimself,

ich bin gerade dabei ein Programm zu entwerfen, welches Numerisch Nullstellen berechnet.
Um natürlich verschiedene Funktionen vrwenden zu können, versuche ich einen Funktionsparser zu programmieren, was allerdings nicht ganz klappt. Da ich zufällig deinen Beitrag gerade lese, wollte ich fragen, ob du mir helfen könntest und mir deinen Funktionsparser ziegen könntest.
Wäre eine sehr große Hilfe!!

VG Caro
 
Da das 4 Jahre her ist kann ich es dir nicht mehr ganz genau erklären. Wichtig zum verstehen ist die Funktion pos0, welche die Position des char c im String s in der innersten Klammerebene zurückgibt falls c innerhalb der innersten Klammer ist, sonst -1.

Am Anfang wird also geschaut ob ein + in der innersten Klammer ist, wenn ja dann rekursiv linken Teil + rekursiv rechten Teil. Nach dem Prinzip arbeitet das Ding.

Code: 
public class Parser {
	public static double h = 1E-8;

	public static double a = -3;

	private final double Pi = 3.14592653489;

	private final double e = 2.718281828459;

	private double x1;

	/*
	 * Vor dem parsen werden die Leerzeichen entfernt
	 */
	public double StrToDbl(String s, double x) {
		x1 = x;
		if (s.equals("")) {
			return 0;
		}
		s.trim();
		if (s.charAt(0) == '-') {
			s = "0" + s;
		}
		s = vereinfache(s);
		return parse(s);
	}

	private String vereinfache(String s) {
		for (int k = 0; k <= s.length() - 1; ++k) {
			if (s.length() - k > 3) {
				switch (s.charAt(k)) {
				case 's': {
					if (s.charAt(k + 1) == 'i') {
						s = s.substring(0, k) + "s"
								+ s.substring(k + 3, s.length());
						break;
					} else {
						s = s.substring(0, k) + "w"
								+ s.substring(k + 4, s.length());
						break;
					}
				}
				case 'c': {
					s = s.substring(0, k) + "c"
							+ s.substring(k + 3, s.length());
					break;
				}
				case 't': {
					s = s.substring(0, k) + "t"
							+ s.substring(k + 3, s.length());
					break;
				}
				case 'l': {
					if (s.charAt(k + 1) == 'o') {
						s = s.substring(0, k) + "l"
								+ s.substring(k + 3, s.length());
						break;
					} else {
						s = s.substring(0, k) + "n"
								+ s.substring(k + 1, s.length());
						break;
					}
				}
				case 'p': {
					s = s.substring(0, k) + "p"
							+ s.substring(k + 2, s.length());
					break;
				}
				}
			}
		}
		return s;
	}

	private int pos0(char c, String s) {
		int k, z;

		z = 0;
		for (k = s.length() - 1; k >= 0; --k) {
			if (s.charAt(k) == '(') {
				++z;
			}
			if (s.charAt(k) == ')') {
				--z;
			}
			if ((s.charAt(k) == c) && (z == 0)) {
				return k;
			}
		}
		return -1;
	}

	private double parse(String s) {
		if (s.equals("")) {
			return 0;
		}
		s = s.trim();
		if (pos0('+', s) > -1) {
			return parse(s.substring(0, pos0('+', s)))
					+ parse(s.substring(pos0('+', s) + 1, s.length()));
		} else if (pos0('-', s) > -1) {
			return parse(s.substring(0, pos0('-', s)))
					- parse(s.substring(pos0('-', s) + 1, s.length()));
		} else if (pos0('*', s) > -1) {
			return parse(s.substring(0, pos0('*', s)))
					* parse(s.substring(pos0('*', s) + 1, s.length()));
		} else if (pos0('/', s) > -1) {
			return parse(s.substring(0, pos0('/', s)))
					/ parse(s.substring(pos0('/', s) + 1, s.length()));
		} else if (pos0('^', s) > -1) {
			return Math.pow(parse(s.substring(0, pos0('^', s))), parse(s
					.substring(pos0('^', s) + 1, s.length())));
		} else if (pos0('w', s) > -1) {
			return Math.sqrt(parse(s.substring(pos0('w', s) + 1, s.length())));
		} else if (pos0('s', s) > -1) {
			return Math.sin(parse(s.substring(pos0('s', s) + 1, s.length())));
		} else if (pos0('t', s) > -1) {
			return Math.tan(parse(s.substring(pos0('t', s) + 1, s.length())));
		} else if (pos0('c', s) > -1) {
			return Math.cos(parse(s.substring(pos0('c', s) + 1, s.length())));
		} else if (pos0('l', s) > -1) {
			return Math.log(parse(s.substring(pos0('l', s) + 1, s.length())));
		} else if (pos0('n', s) > -1) {
			return Math.log(parse(s.substring(pos0('n', s) + 1, s.length())))
					/ Math.log(2);
		} else if ((s.equals("") == false) && (s.charAt(0) == '(')) {
			s = s.substring(1, s.length() - 1);
			return parse(s);
		} else if (s.equals("x")) {
			return x1;
		} else if (s.equals("a")) {
			return a;
		} else if (s.equals("h")) {
			return h;
		} else if (s.equals("p")) {
			return Pi;
		} else if (s.equals("e")) {
			return e;
		} else {
			double x;
			try {
				x = Double.parseDouble(s);
				return x;
			} catch (Exception ex) {
			}
		}
		return 0;
	}
}
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück